github.com/wata727/tflint@v0.12.2-0.20191013070026-96dd0d36f385/client/aws_ec2_mock.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: ../vendor/github.com/aws/aws-sdk-go/service/ec2/ec2iface/interface.go 3 4 // Package client is a generated GoMock package. 5 package client 6 7 import ( 8 aws "github.com/aws/aws-sdk-go/aws" 9 request "github.com/aws/aws-sdk-go/aws/request" 10 ec2 "github.com/aws/aws-sdk-go/service/ec2" 11 gomock "github.com/golang/mock/gomock" 12 reflect "reflect" 13 ) 14 15 // MockEC2API is a mock of EC2API interface 16 type MockEC2API struct { 17 ctrl *gomock.Controller 18 recorder *MockEC2APIMockRecorder 19 } 20 21 // MockEC2APIMockRecorder is the mock recorder for MockEC2API 22 type MockEC2APIMockRecorder struct { 23 mock *MockEC2API 24 } 25 26 // NewMockEC2API creates a new mock instance 27 func NewMockEC2API(ctrl *gomock.Controller) *MockEC2API { 28 mock := &MockEC2API{ctrl: ctrl} 29 mock.recorder = &MockEC2APIMockRecorder{mock} 30 return mock 31 } 32 33 // EXPECT returns an object that allows the caller to indicate expected use 34 func (m *MockEC2API) EXPECT() *MockEC2APIMockRecorder { 35 return m.recorder 36 } 37 38 // AcceptReservedInstancesExchangeQuote mocks base method 39 func (m *MockEC2API) AcceptReservedInstancesExchangeQuote(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) { 40 m.ctrl.T.Helper() 41 ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuote", arg0) 42 ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) 43 ret1, _ := ret[1].(error) 44 return ret0, ret1 45 } 46 47 // AcceptReservedInstancesExchangeQuote indicates an expected call of AcceptReservedInstancesExchangeQuote 48 func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call { 49 mr.mock.ctrl.T.Helper() 50 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuote), arg0) 51 } 52 53 // AcceptReservedInstancesExchangeQuoteWithContext mocks base method 54 func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteWithContext(arg0 aws.Context, arg1 *ec2.AcceptReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.AcceptReservedInstancesExchangeQuoteOutput, error) { 55 m.ctrl.T.Helper() 56 varargs := []interface{}{arg0, arg1} 57 for _, a := range arg2 { 58 varargs = append(varargs, a) 59 } 60 ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteWithContext", varargs...) 61 ret0, _ := ret[0].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) 62 ret1, _ := ret[1].(error) 63 return ret0, ret1 64 } 65 66 // AcceptReservedInstancesExchangeQuoteWithContext indicates an expected call of AcceptReservedInstancesExchangeQuoteWithContext 67 func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 68 mr.mock.ctrl.T.Helper() 69 varargs := append([]interface{}{arg0, arg1}, arg2...) 70 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteWithContext), varargs...) 71 } 72 73 // AcceptReservedInstancesExchangeQuoteRequest mocks base method 74 func (m *MockEC2API) AcceptReservedInstancesExchangeQuoteRequest(arg0 *ec2.AcceptReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.AcceptReservedInstancesExchangeQuoteOutput) { 75 m.ctrl.T.Helper() 76 ret := m.ctrl.Call(m, "AcceptReservedInstancesExchangeQuoteRequest", arg0) 77 ret0, _ := ret[0].(*request.Request) 78 ret1, _ := ret[1].(*ec2.AcceptReservedInstancesExchangeQuoteOutput) 79 return ret0, ret1 80 } 81 82 // AcceptReservedInstancesExchangeQuoteRequest indicates an expected call of AcceptReservedInstancesExchangeQuoteRequest 83 func (mr *MockEC2APIMockRecorder) AcceptReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call { 84 mr.mock.ctrl.T.Helper() 85 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptReservedInstancesExchangeQuoteRequest), arg0) 86 } 87 88 // AcceptTransitGatewayVpcAttachment mocks base method 89 func (m *MockEC2API) AcceptTransitGatewayVpcAttachment(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) { 90 m.ctrl.T.Helper() 91 ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachment", arg0) 92 ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) 93 ret1, _ := ret[1].(error) 94 return ret0, ret1 95 } 96 97 // AcceptTransitGatewayVpcAttachment indicates an expected call of AcceptTransitGatewayVpcAttachment 98 func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { 99 mr.mock.ctrl.T.Helper() 100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachment), arg0) 101 } 102 103 // AcceptTransitGatewayVpcAttachmentWithContext mocks base method 104 func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentWithContext(arg0 aws.Context, arg1 *ec2.AcceptTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.AcceptTransitGatewayVpcAttachmentOutput, error) { 105 m.ctrl.T.Helper() 106 varargs := []interface{}{arg0, arg1} 107 for _, a := range arg2 { 108 varargs = append(varargs, a) 109 } 110 ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentWithContext", varargs...) 111 ret0, _ := ret[0].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) 112 ret1, _ := ret[1].(error) 113 return ret0, ret1 114 } 115 116 // AcceptTransitGatewayVpcAttachmentWithContext indicates an expected call of AcceptTransitGatewayVpcAttachmentWithContext 117 func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 118 mr.mock.ctrl.T.Helper() 119 varargs := append([]interface{}{arg0, arg1}, arg2...) 120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentWithContext), varargs...) 121 } 122 123 // AcceptTransitGatewayVpcAttachmentRequest mocks base method 124 func (m *MockEC2API) AcceptTransitGatewayVpcAttachmentRequest(arg0 *ec2.AcceptTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.AcceptTransitGatewayVpcAttachmentOutput) { 125 m.ctrl.T.Helper() 126 ret := m.ctrl.Call(m, "AcceptTransitGatewayVpcAttachmentRequest", arg0) 127 ret0, _ := ret[0].(*request.Request) 128 ret1, _ := ret[1].(*ec2.AcceptTransitGatewayVpcAttachmentOutput) 129 return ret0, ret1 130 } 131 132 // AcceptTransitGatewayVpcAttachmentRequest indicates an expected call of AcceptTransitGatewayVpcAttachmentRequest 133 func (mr *MockEC2APIMockRecorder) AcceptTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { 134 mr.mock.ctrl.T.Helper() 135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptTransitGatewayVpcAttachmentRequest), arg0) 136 } 137 138 // AcceptVpcEndpointConnections mocks base method 139 func (m *MockEC2API) AcceptVpcEndpointConnections(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*ec2.AcceptVpcEndpointConnectionsOutput, error) { 140 m.ctrl.T.Helper() 141 ret := m.ctrl.Call(m, "AcceptVpcEndpointConnections", arg0) 142 ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput) 143 ret1, _ := ret[1].(error) 144 return ret0, ret1 145 } 146 147 // AcceptVpcEndpointConnections indicates an expected call of AcceptVpcEndpointConnections 148 func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnections(arg0 interface{}) *gomock.Call { 149 mr.mock.ctrl.T.Helper() 150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnections), arg0) 151 } 152 153 // AcceptVpcEndpointConnectionsWithContext mocks base method 154 func (m *MockEC2API) AcceptVpcEndpointConnectionsWithContext(arg0 aws.Context, arg1 *ec2.AcceptVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.AcceptVpcEndpointConnectionsOutput, error) { 155 m.ctrl.T.Helper() 156 varargs := []interface{}{arg0, arg1} 157 for _, a := range arg2 { 158 varargs = append(varargs, a) 159 } 160 ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsWithContext", varargs...) 161 ret0, _ := ret[0].(*ec2.AcceptVpcEndpointConnectionsOutput) 162 ret1, _ := ret[1].(error) 163 return ret0, ret1 164 } 165 166 // AcceptVpcEndpointConnectionsWithContext indicates an expected call of AcceptVpcEndpointConnectionsWithContext 167 func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 168 mr.mock.ctrl.T.Helper() 169 varargs := append([]interface{}{arg0, arg1}, arg2...) 170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnectionsWithContext), varargs...) 171 } 172 173 // AcceptVpcEndpointConnectionsRequest mocks base method 174 func (m *MockEC2API) AcceptVpcEndpointConnectionsRequest(arg0 *ec2.AcceptVpcEndpointConnectionsInput) (*request.Request, *ec2.AcceptVpcEndpointConnectionsOutput) { 175 m.ctrl.T.Helper() 176 ret := m.ctrl.Call(m, "AcceptVpcEndpointConnectionsRequest", arg0) 177 ret0, _ := ret[0].(*request.Request) 178 ret1, _ := ret[1].(*ec2.AcceptVpcEndpointConnectionsOutput) 179 return ret0, ret1 180 } 181 182 // AcceptVpcEndpointConnectionsRequest indicates an expected call of AcceptVpcEndpointConnectionsRequest 183 func (mr *MockEC2APIMockRecorder) AcceptVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { 184 mr.mock.ctrl.T.Helper() 185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcEndpointConnectionsRequest), arg0) 186 } 187 188 // AcceptVpcPeeringConnection mocks base method 189 func (m *MockEC2API) AcceptVpcPeeringConnection(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*ec2.AcceptVpcPeeringConnectionOutput, error) { 190 m.ctrl.T.Helper() 191 ret := m.ctrl.Call(m, "AcceptVpcPeeringConnection", arg0) 192 ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput) 193 ret1, _ := ret[1].(error) 194 return ret0, ret1 195 } 196 197 // AcceptVpcPeeringConnection indicates an expected call of AcceptVpcPeeringConnection 198 func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnection(arg0 interface{}) *gomock.Call { 199 mr.mock.ctrl.T.Helper() 200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnection), arg0) 201 } 202 203 // AcceptVpcPeeringConnectionWithContext mocks base method 204 func (m *MockEC2API) AcceptVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *ec2.AcceptVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.AcceptVpcPeeringConnectionOutput, error) { 205 m.ctrl.T.Helper() 206 varargs := []interface{}{arg0, arg1} 207 for _, a := range arg2 { 208 varargs = append(varargs, a) 209 } 210 ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionWithContext", varargs...) 211 ret0, _ := ret[0].(*ec2.AcceptVpcPeeringConnectionOutput) 212 ret1, _ := ret[1].(error) 213 return ret0, ret1 214 } 215 216 // AcceptVpcPeeringConnectionWithContext indicates an expected call of AcceptVpcPeeringConnectionWithContext 217 func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 218 mr.mock.ctrl.T.Helper() 219 varargs := append([]interface{}{arg0, arg1}, arg2...) 220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionWithContext), varargs...) 221 } 222 223 // AcceptVpcPeeringConnectionRequest mocks base method 224 func (m *MockEC2API) AcceptVpcPeeringConnectionRequest(arg0 *ec2.AcceptVpcPeeringConnectionInput) (*request.Request, *ec2.AcceptVpcPeeringConnectionOutput) { 225 m.ctrl.T.Helper() 226 ret := m.ctrl.Call(m, "AcceptVpcPeeringConnectionRequest", arg0) 227 ret0, _ := ret[0].(*request.Request) 228 ret1, _ := ret[1].(*ec2.AcceptVpcPeeringConnectionOutput) 229 return ret0, ret1 230 } 231 232 // AcceptVpcPeeringConnectionRequest indicates an expected call of AcceptVpcPeeringConnectionRequest 233 func (mr *MockEC2APIMockRecorder) AcceptVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { 234 mr.mock.ctrl.T.Helper() 235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AcceptVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).AcceptVpcPeeringConnectionRequest), arg0) 236 } 237 238 // AdvertiseByoipCidr mocks base method 239 func (m *MockEC2API) AdvertiseByoipCidr(arg0 *ec2.AdvertiseByoipCidrInput) (*ec2.AdvertiseByoipCidrOutput, error) { 240 m.ctrl.T.Helper() 241 ret := m.ctrl.Call(m, "AdvertiseByoipCidr", arg0) 242 ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput) 243 ret1, _ := ret[1].(error) 244 return ret0, ret1 245 } 246 247 // AdvertiseByoipCidr indicates an expected call of AdvertiseByoipCidr 248 func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidr(arg0 interface{}) *gomock.Call { 249 mr.mock.ctrl.T.Helper() 250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidr", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidr), arg0) 251 } 252 253 // AdvertiseByoipCidrWithContext mocks base method 254 func (m *MockEC2API) AdvertiseByoipCidrWithContext(arg0 aws.Context, arg1 *ec2.AdvertiseByoipCidrInput, arg2 ...request.Option) (*ec2.AdvertiseByoipCidrOutput, error) { 255 m.ctrl.T.Helper() 256 varargs := []interface{}{arg0, arg1} 257 for _, a := range arg2 { 258 varargs = append(varargs, a) 259 } 260 ret := m.ctrl.Call(m, "AdvertiseByoipCidrWithContext", varargs...) 261 ret0, _ := ret[0].(*ec2.AdvertiseByoipCidrOutput) 262 ret1, _ := ret[1].(error) 263 return ret0, ret1 264 } 265 266 // AdvertiseByoipCidrWithContext indicates an expected call of AdvertiseByoipCidrWithContext 267 func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 268 mr.mock.ctrl.T.Helper() 269 varargs := append([]interface{}{arg0, arg1}, arg2...) 270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrWithContext), varargs...) 271 } 272 273 // AdvertiseByoipCidrRequest mocks base method 274 func (m *MockEC2API) AdvertiseByoipCidrRequest(arg0 *ec2.AdvertiseByoipCidrInput) (*request.Request, *ec2.AdvertiseByoipCidrOutput) { 275 m.ctrl.T.Helper() 276 ret := m.ctrl.Call(m, "AdvertiseByoipCidrRequest", arg0) 277 ret0, _ := ret[0].(*request.Request) 278 ret1, _ := ret[1].(*ec2.AdvertiseByoipCidrOutput) 279 return ret0, ret1 280 } 281 282 // AdvertiseByoipCidrRequest indicates an expected call of AdvertiseByoipCidrRequest 283 func (mr *MockEC2APIMockRecorder) AdvertiseByoipCidrRequest(arg0 interface{}) *gomock.Call { 284 mr.mock.ctrl.T.Helper() 285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AdvertiseByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).AdvertiseByoipCidrRequest), arg0) 286 } 287 288 // AllocateAddress mocks base method 289 func (m *MockEC2API) AllocateAddress(arg0 *ec2.AllocateAddressInput) (*ec2.AllocateAddressOutput, error) { 290 m.ctrl.T.Helper() 291 ret := m.ctrl.Call(m, "AllocateAddress", arg0) 292 ret0, _ := ret[0].(*ec2.AllocateAddressOutput) 293 ret1, _ := ret[1].(error) 294 return ret0, ret1 295 } 296 297 // AllocateAddress indicates an expected call of AllocateAddress 298 func (mr *MockEC2APIMockRecorder) AllocateAddress(arg0 interface{}) *gomock.Call { 299 mr.mock.ctrl.T.Helper() 300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddress", reflect.TypeOf((*MockEC2API)(nil).AllocateAddress), arg0) 301 } 302 303 // AllocateAddressWithContext mocks base method 304 func (m *MockEC2API) AllocateAddressWithContext(arg0 aws.Context, arg1 *ec2.AllocateAddressInput, arg2 ...request.Option) (*ec2.AllocateAddressOutput, error) { 305 m.ctrl.T.Helper() 306 varargs := []interface{}{arg0, arg1} 307 for _, a := range arg2 { 308 varargs = append(varargs, a) 309 } 310 ret := m.ctrl.Call(m, "AllocateAddressWithContext", varargs...) 311 ret0, _ := ret[0].(*ec2.AllocateAddressOutput) 312 ret1, _ := ret[1].(error) 313 return ret0, ret1 314 } 315 316 // AllocateAddressWithContext indicates an expected call of AllocateAddressWithContext 317 func (mr *MockEC2APIMockRecorder) AllocateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 318 mr.mock.ctrl.T.Helper() 319 varargs := append([]interface{}{arg0, arg1}, arg2...) 320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressWithContext), varargs...) 321 } 322 323 // AllocateAddressRequest mocks base method 324 func (m *MockEC2API) AllocateAddressRequest(arg0 *ec2.AllocateAddressInput) (*request.Request, *ec2.AllocateAddressOutput) { 325 m.ctrl.T.Helper() 326 ret := m.ctrl.Call(m, "AllocateAddressRequest", arg0) 327 ret0, _ := ret[0].(*request.Request) 328 ret1, _ := ret[1].(*ec2.AllocateAddressOutput) 329 return ret0, ret1 330 } 331 332 // AllocateAddressRequest indicates an expected call of AllocateAddressRequest 333 func (mr *MockEC2APIMockRecorder) AllocateAddressRequest(arg0 interface{}) *gomock.Call { 334 mr.mock.ctrl.T.Helper() 335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateAddressRequest), arg0) 336 } 337 338 // AllocateHosts mocks base method 339 func (m *MockEC2API) AllocateHosts(arg0 *ec2.AllocateHostsInput) (*ec2.AllocateHostsOutput, error) { 340 m.ctrl.T.Helper() 341 ret := m.ctrl.Call(m, "AllocateHosts", arg0) 342 ret0, _ := ret[0].(*ec2.AllocateHostsOutput) 343 ret1, _ := ret[1].(error) 344 return ret0, ret1 345 } 346 347 // AllocateHosts indicates an expected call of AllocateHosts 348 func (mr *MockEC2APIMockRecorder) AllocateHosts(arg0 interface{}) *gomock.Call { 349 mr.mock.ctrl.T.Helper() 350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHosts", reflect.TypeOf((*MockEC2API)(nil).AllocateHosts), arg0) 351 } 352 353 // AllocateHostsWithContext mocks base method 354 func (m *MockEC2API) AllocateHostsWithContext(arg0 aws.Context, arg1 *ec2.AllocateHostsInput, arg2 ...request.Option) (*ec2.AllocateHostsOutput, error) { 355 m.ctrl.T.Helper() 356 varargs := []interface{}{arg0, arg1} 357 for _, a := range arg2 { 358 varargs = append(varargs, a) 359 } 360 ret := m.ctrl.Call(m, "AllocateHostsWithContext", varargs...) 361 ret0, _ := ret[0].(*ec2.AllocateHostsOutput) 362 ret1, _ := ret[1].(error) 363 return ret0, ret1 364 } 365 366 // AllocateHostsWithContext indicates an expected call of AllocateHostsWithContext 367 func (mr *MockEC2APIMockRecorder) AllocateHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 368 mr.mock.ctrl.T.Helper() 369 varargs := append([]interface{}{arg0, arg1}, arg2...) 370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsWithContext), varargs...) 371 } 372 373 // AllocateHostsRequest mocks base method 374 func (m *MockEC2API) AllocateHostsRequest(arg0 *ec2.AllocateHostsInput) (*request.Request, *ec2.AllocateHostsOutput) { 375 m.ctrl.T.Helper() 376 ret := m.ctrl.Call(m, "AllocateHostsRequest", arg0) 377 ret0, _ := ret[0].(*request.Request) 378 ret1, _ := ret[1].(*ec2.AllocateHostsOutput) 379 return ret0, ret1 380 } 381 382 // AllocateHostsRequest indicates an expected call of AllocateHostsRequest 383 func (mr *MockEC2APIMockRecorder) AllocateHostsRequest(arg0 interface{}) *gomock.Call { 384 mr.mock.ctrl.T.Helper() 385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AllocateHostsRequest", reflect.TypeOf((*MockEC2API)(nil).AllocateHostsRequest), arg0) 386 } 387 388 // ApplySecurityGroupsToClientVpnTargetNetwork mocks base method 389 func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) { 390 m.ctrl.T.Helper() 391 ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetwork", arg0) 392 ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) 393 ret1, _ := ret[1].(error) 394 return ret0, ret1 395 } 396 397 // ApplySecurityGroupsToClientVpnTargetNetwork indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetwork 398 func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { 399 mr.mock.ctrl.T.Helper() 400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetwork), arg0) 401 } 402 403 // ApplySecurityGroupsToClientVpnTargetNetworkWithContext mocks base method 404 func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0 aws.Context, arg1 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput, error) { 405 m.ctrl.T.Helper() 406 varargs := []interface{}{arg0, arg1} 407 for _, a := range arg2 { 408 varargs = append(varargs, a) 409 } 410 ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", varargs...) 411 ret0, _ := ret[0].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) 412 ret1, _ := ret[1].(error) 413 return ret0, ret1 414 } 415 416 // ApplySecurityGroupsToClientVpnTargetNetworkWithContext indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkWithContext 417 func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 418 mr.mock.ctrl.T.Helper() 419 varargs := append([]interface{}{arg0, arg1}, arg2...) 420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkWithContext), varargs...) 421 } 422 423 // ApplySecurityGroupsToClientVpnTargetNetworkRequest mocks base method 424 func (m *MockEC2API) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 *ec2.ApplySecurityGroupsToClientVpnTargetNetworkInput) (*request.Request, *ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) { 425 m.ctrl.T.Helper() 426 ret := m.ctrl.Call(m, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", arg0) 427 ret0, _ := ret[0].(*request.Request) 428 ret1, _ := ret[1].(*ec2.ApplySecurityGroupsToClientVpnTargetNetworkOutput) 429 return ret0, ret1 430 } 431 432 // ApplySecurityGroupsToClientVpnTargetNetworkRequest indicates an expected call of ApplySecurityGroupsToClientVpnTargetNetworkRequest 433 func (mr *MockEC2APIMockRecorder) ApplySecurityGroupsToClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { 434 mr.mock.ctrl.T.Helper() 435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ApplySecurityGroupsToClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).ApplySecurityGroupsToClientVpnTargetNetworkRequest), arg0) 436 } 437 438 // AssignIpv6Addresses mocks base method 439 func (m *MockEC2API) AssignIpv6Addresses(arg0 *ec2.AssignIpv6AddressesInput) (*ec2.AssignIpv6AddressesOutput, error) { 440 m.ctrl.T.Helper() 441 ret := m.ctrl.Call(m, "AssignIpv6Addresses", arg0) 442 ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput) 443 ret1, _ := ret[1].(error) 444 return ret0, ret1 445 } 446 447 // AssignIpv6Addresses indicates an expected call of AssignIpv6Addresses 448 func (mr *MockEC2APIMockRecorder) AssignIpv6Addresses(arg0 interface{}) *gomock.Call { 449 mr.mock.ctrl.T.Helper() 450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6Addresses), arg0) 451 } 452 453 // AssignIpv6AddressesWithContext mocks base method 454 func (m *MockEC2API) AssignIpv6AddressesWithContext(arg0 aws.Context, arg1 *ec2.AssignIpv6AddressesInput, arg2 ...request.Option) (*ec2.AssignIpv6AddressesOutput, error) { 455 m.ctrl.T.Helper() 456 varargs := []interface{}{arg0, arg1} 457 for _, a := range arg2 { 458 varargs = append(varargs, a) 459 } 460 ret := m.ctrl.Call(m, "AssignIpv6AddressesWithContext", varargs...) 461 ret0, _ := ret[0].(*ec2.AssignIpv6AddressesOutput) 462 ret1, _ := ret[1].(error) 463 return ret0, ret1 464 } 465 466 // AssignIpv6AddressesWithContext indicates an expected call of AssignIpv6AddressesWithContext 467 func (mr *MockEC2APIMockRecorder) AssignIpv6AddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 468 mr.mock.ctrl.T.Helper() 469 varargs := append([]interface{}{arg0, arg1}, arg2...) 470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesWithContext), varargs...) 471 } 472 473 // AssignIpv6AddressesRequest mocks base method 474 func (m *MockEC2API) AssignIpv6AddressesRequest(arg0 *ec2.AssignIpv6AddressesInput) (*request.Request, *ec2.AssignIpv6AddressesOutput) { 475 m.ctrl.T.Helper() 476 ret := m.ctrl.Call(m, "AssignIpv6AddressesRequest", arg0) 477 ret0, _ := ret[0].(*request.Request) 478 ret1, _ := ret[1].(*ec2.AssignIpv6AddressesOutput) 479 return ret0, ret1 480 } 481 482 // AssignIpv6AddressesRequest indicates an expected call of AssignIpv6AddressesRequest 483 func (mr *MockEC2APIMockRecorder) AssignIpv6AddressesRequest(arg0 interface{}) *gomock.Call { 484 mr.mock.ctrl.T.Helper() 485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignIpv6AddressesRequest), arg0) 486 } 487 488 // AssignPrivateIpAddresses mocks base method 489 func (m *MockEC2API) AssignPrivateIpAddresses(arg0 *ec2.AssignPrivateIpAddressesInput) (*ec2.AssignPrivateIpAddressesOutput, error) { 490 m.ctrl.T.Helper() 491 ret := m.ctrl.Call(m, "AssignPrivateIpAddresses", arg0) 492 ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput) 493 ret1, _ := ret[1].(error) 494 return ret0, ret1 495 } 496 497 // AssignPrivateIpAddresses indicates an expected call of AssignPrivateIpAddresses 498 func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddresses(arg0 interface{}) *gomock.Call { 499 mr.mock.ctrl.T.Helper() 500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddresses), arg0) 501 } 502 503 // AssignPrivateIpAddressesWithContext mocks base method 504 func (m *MockEC2API) AssignPrivateIpAddressesWithContext(arg0 aws.Context, arg1 *ec2.AssignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.AssignPrivateIpAddressesOutput, error) { 505 m.ctrl.T.Helper() 506 varargs := []interface{}{arg0, arg1} 507 for _, a := range arg2 { 508 varargs = append(varargs, a) 509 } 510 ret := m.ctrl.Call(m, "AssignPrivateIpAddressesWithContext", varargs...) 511 ret0, _ := ret[0].(*ec2.AssignPrivateIpAddressesOutput) 512 ret1, _ := ret[1].(error) 513 return ret0, ret1 514 } 515 516 // AssignPrivateIpAddressesWithContext indicates an expected call of AssignPrivateIpAddressesWithContext 517 func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 518 mr.mock.ctrl.T.Helper() 519 varargs := append([]interface{}{arg0, arg1}, arg2...) 520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesWithContext), varargs...) 521 } 522 523 // AssignPrivateIpAddressesRequest mocks base method 524 func (m *MockEC2API) AssignPrivateIpAddressesRequest(arg0 *ec2.AssignPrivateIpAddressesInput) (*request.Request, *ec2.AssignPrivateIpAddressesOutput) { 525 m.ctrl.T.Helper() 526 ret := m.ctrl.Call(m, "AssignPrivateIpAddressesRequest", arg0) 527 ret0, _ := ret[0].(*request.Request) 528 ret1, _ := ret[1].(*ec2.AssignPrivateIpAddressesOutput) 529 return ret0, ret1 530 } 531 532 // AssignPrivateIpAddressesRequest indicates an expected call of AssignPrivateIpAddressesRequest 533 func (mr *MockEC2APIMockRecorder) AssignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call { 534 mr.mock.ctrl.T.Helper() 535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).AssignPrivateIpAddressesRequest), arg0) 536 } 537 538 // AssociateAddress mocks base method 539 func (m *MockEC2API) AssociateAddress(arg0 *ec2.AssociateAddressInput) (*ec2.AssociateAddressOutput, error) { 540 m.ctrl.T.Helper() 541 ret := m.ctrl.Call(m, "AssociateAddress", arg0) 542 ret0, _ := ret[0].(*ec2.AssociateAddressOutput) 543 ret1, _ := ret[1].(error) 544 return ret0, ret1 545 } 546 547 // AssociateAddress indicates an expected call of AssociateAddress 548 func (mr *MockEC2APIMockRecorder) AssociateAddress(arg0 interface{}) *gomock.Call { 549 mr.mock.ctrl.T.Helper() 550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddress", reflect.TypeOf((*MockEC2API)(nil).AssociateAddress), arg0) 551 } 552 553 // AssociateAddressWithContext mocks base method 554 func (m *MockEC2API) AssociateAddressWithContext(arg0 aws.Context, arg1 *ec2.AssociateAddressInput, arg2 ...request.Option) (*ec2.AssociateAddressOutput, error) { 555 m.ctrl.T.Helper() 556 varargs := []interface{}{arg0, arg1} 557 for _, a := range arg2 { 558 varargs = append(varargs, a) 559 } 560 ret := m.ctrl.Call(m, "AssociateAddressWithContext", varargs...) 561 ret0, _ := ret[0].(*ec2.AssociateAddressOutput) 562 ret1, _ := ret[1].(error) 563 return ret0, ret1 564 } 565 566 // AssociateAddressWithContext indicates an expected call of AssociateAddressWithContext 567 func (mr *MockEC2APIMockRecorder) AssociateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 568 mr.mock.ctrl.T.Helper() 569 varargs := append([]interface{}{arg0, arg1}, arg2...) 570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateAddressWithContext), varargs...) 571 } 572 573 // AssociateAddressRequest mocks base method 574 func (m *MockEC2API) AssociateAddressRequest(arg0 *ec2.AssociateAddressInput) (*request.Request, *ec2.AssociateAddressOutput) { 575 m.ctrl.T.Helper() 576 ret := m.ctrl.Call(m, "AssociateAddressRequest", arg0) 577 ret0, _ := ret[0].(*request.Request) 578 ret1, _ := ret[1].(*ec2.AssociateAddressOutput) 579 return ret0, ret1 580 } 581 582 // AssociateAddressRequest indicates an expected call of AssociateAddressRequest 583 func (mr *MockEC2APIMockRecorder) AssociateAddressRequest(arg0 interface{}) *gomock.Call { 584 mr.mock.ctrl.T.Helper() 585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateAddressRequest), arg0) 586 } 587 588 // AssociateClientVpnTargetNetwork mocks base method 589 func (m *MockEC2API) AssociateClientVpnTargetNetwork(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*ec2.AssociateClientVpnTargetNetworkOutput, error) { 590 m.ctrl.T.Helper() 591 ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetwork", arg0) 592 ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput) 593 ret1, _ := ret[1].(error) 594 return ret0, ret1 595 } 596 597 // AssociateClientVpnTargetNetwork indicates an expected call of AssociateClientVpnTargetNetwork 598 func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { 599 mr.mock.ctrl.T.Helper() 600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetwork), arg0) 601 } 602 603 // AssociateClientVpnTargetNetworkWithContext mocks base method 604 func (m *MockEC2API) AssociateClientVpnTargetNetworkWithContext(arg0 aws.Context, arg1 *ec2.AssociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.AssociateClientVpnTargetNetworkOutput, error) { 605 m.ctrl.T.Helper() 606 varargs := []interface{}{arg0, arg1} 607 for _, a := range arg2 { 608 varargs = append(varargs, a) 609 } 610 ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkWithContext", varargs...) 611 ret0, _ := ret[0].(*ec2.AssociateClientVpnTargetNetworkOutput) 612 ret1, _ := ret[1].(error) 613 return ret0, ret1 614 } 615 616 // AssociateClientVpnTargetNetworkWithContext indicates an expected call of AssociateClientVpnTargetNetworkWithContext 617 func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 618 mr.mock.ctrl.T.Helper() 619 varargs := append([]interface{}{arg0, arg1}, arg2...) 620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetworkWithContext), varargs...) 621 } 622 623 // AssociateClientVpnTargetNetworkRequest mocks base method 624 func (m *MockEC2API) AssociateClientVpnTargetNetworkRequest(arg0 *ec2.AssociateClientVpnTargetNetworkInput) (*request.Request, *ec2.AssociateClientVpnTargetNetworkOutput) { 625 m.ctrl.T.Helper() 626 ret := m.ctrl.Call(m, "AssociateClientVpnTargetNetworkRequest", arg0) 627 ret0, _ := ret[0].(*request.Request) 628 ret1, _ := ret[1].(*ec2.AssociateClientVpnTargetNetworkOutput) 629 return ret0, ret1 630 } 631 632 // AssociateClientVpnTargetNetworkRequest indicates an expected call of AssociateClientVpnTargetNetworkRequest 633 func (mr *MockEC2APIMockRecorder) AssociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { 634 mr.mock.ctrl.T.Helper() 635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateClientVpnTargetNetworkRequest), arg0) 636 } 637 638 // AssociateDhcpOptions mocks base method 639 func (m *MockEC2API) AssociateDhcpOptions(arg0 *ec2.AssociateDhcpOptionsInput) (*ec2.AssociateDhcpOptionsOutput, error) { 640 m.ctrl.T.Helper() 641 ret := m.ctrl.Call(m, "AssociateDhcpOptions", arg0) 642 ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput) 643 ret1, _ := ret[1].(error) 644 return ret0, ret1 645 } 646 647 // AssociateDhcpOptions indicates an expected call of AssociateDhcpOptions 648 func (mr *MockEC2APIMockRecorder) AssociateDhcpOptions(arg0 interface{}) *gomock.Call { 649 mr.mock.ctrl.T.Helper() 650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptions), arg0) 651 } 652 653 // AssociateDhcpOptionsWithContext mocks base method 654 func (m *MockEC2API) AssociateDhcpOptionsWithContext(arg0 aws.Context, arg1 *ec2.AssociateDhcpOptionsInput, arg2 ...request.Option) (*ec2.AssociateDhcpOptionsOutput, error) { 655 m.ctrl.T.Helper() 656 varargs := []interface{}{arg0, arg1} 657 for _, a := range arg2 { 658 varargs = append(varargs, a) 659 } 660 ret := m.ctrl.Call(m, "AssociateDhcpOptionsWithContext", varargs...) 661 ret0, _ := ret[0].(*ec2.AssociateDhcpOptionsOutput) 662 ret1, _ := ret[1].(error) 663 return ret0, ret1 664 } 665 666 // AssociateDhcpOptionsWithContext indicates an expected call of AssociateDhcpOptionsWithContext 667 func (mr *MockEC2APIMockRecorder) AssociateDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 668 mr.mock.ctrl.T.Helper() 669 varargs := append([]interface{}{arg0, arg1}, arg2...) 670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsWithContext), varargs...) 671 } 672 673 // AssociateDhcpOptionsRequest mocks base method 674 func (m *MockEC2API) AssociateDhcpOptionsRequest(arg0 *ec2.AssociateDhcpOptionsInput) (*request.Request, *ec2.AssociateDhcpOptionsOutput) { 675 m.ctrl.T.Helper() 676 ret := m.ctrl.Call(m, "AssociateDhcpOptionsRequest", arg0) 677 ret0, _ := ret[0].(*request.Request) 678 ret1, _ := ret[1].(*ec2.AssociateDhcpOptionsOutput) 679 return ret0, ret1 680 } 681 682 // AssociateDhcpOptionsRequest indicates an expected call of AssociateDhcpOptionsRequest 683 func (mr *MockEC2APIMockRecorder) AssociateDhcpOptionsRequest(arg0 interface{}) *gomock.Call { 684 mr.mock.ctrl.T.Helper() 685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateDhcpOptionsRequest), arg0) 686 } 687 688 // AssociateIamInstanceProfile mocks base method 689 func (m *MockEC2API) AssociateIamInstanceProfile(arg0 *ec2.AssociateIamInstanceProfileInput) (*ec2.AssociateIamInstanceProfileOutput, error) { 690 m.ctrl.T.Helper() 691 ret := m.ctrl.Call(m, "AssociateIamInstanceProfile", arg0) 692 ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput) 693 ret1, _ := ret[1].(error) 694 return ret0, ret1 695 } 696 697 // AssociateIamInstanceProfile indicates an expected call of AssociateIamInstanceProfile 698 func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfile(arg0 interface{}) *gomock.Call { 699 mr.mock.ctrl.T.Helper() 700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfile), arg0) 701 } 702 703 // AssociateIamInstanceProfileWithContext mocks base method 704 func (m *MockEC2API) AssociateIamInstanceProfileWithContext(arg0 aws.Context, arg1 *ec2.AssociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.AssociateIamInstanceProfileOutput, error) { 705 m.ctrl.T.Helper() 706 varargs := []interface{}{arg0, arg1} 707 for _, a := range arg2 { 708 varargs = append(varargs, a) 709 } 710 ret := m.ctrl.Call(m, "AssociateIamInstanceProfileWithContext", varargs...) 711 ret0, _ := ret[0].(*ec2.AssociateIamInstanceProfileOutput) 712 ret1, _ := ret[1].(error) 713 return ret0, ret1 714 } 715 716 // AssociateIamInstanceProfileWithContext indicates an expected call of AssociateIamInstanceProfileWithContext 717 func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 718 mr.mock.ctrl.T.Helper() 719 varargs := append([]interface{}{arg0, arg1}, arg2...) 720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfileWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfileWithContext), varargs...) 721 } 722 723 // AssociateIamInstanceProfileRequest mocks base method 724 func (m *MockEC2API) AssociateIamInstanceProfileRequest(arg0 *ec2.AssociateIamInstanceProfileInput) (*request.Request, *ec2.AssociateIamInstanceProfileOutput) { 725 m.ctrl.T.Helper() 726 ret := m.ctrl.Call(m, "AssociateIamInstanceProfileRequest", arg0) 727 ret0, _ := ret[0].(*request.Request) 728 ret1, _ := ret[1].(*ec2.AssociateIamInstanceProfileOutput) 729 return ret0, ret1 730 } 731 732 // AssociateIamInstanceProfileRequest indicates an expected call of AssociateIamInstanceProfileRequest 733 func (mr *MockEC2APIMockRecorder) AssociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call { 734 mr.mock.ctrl.T.Helper() 735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateIamInstanceProfileRequest), arg0) 736 } 737 738 // AssociateRouteTable mocks base method 739 func (m *MockEC2API) AssociateRouteTable(arg0 *ec2.AssociateRouteTableInput) (*ec2.AssociateRouteTableOutput, error) { 740 m.ctrl.T.Helper() 741 ret := m.ctrl.Call(m, "AssociateRouteTable", arg0) 742 ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput) 743 ret1, _ := ret[1].(error) 744 return ret0, ret1 745 } 746 747 // AssociateRouteTable indicates an expected call of AssociateRouteTable 748 func (mr *MockEC2APIMockRecorder) AssociateRouteTable(arg0 interface{}) *gomock.Call { 749 mr.mock.ctrl.T.Helper() 750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTable), arg0) 751 } 752 753 // AssociateRouteTableWithContext mocks base method 754 func (m *MockEC2API) AssociateRouteTableWithContext(arg0 aws.Context, arg1 *ec2.AssociateRouteTableInput, arg2 ...request.Option) (*ec2.AssociateRouteTableOutput, error) { 755 m.ctrl.T.Helper() 756 varargs := []interface{}{arg0, arg1} 757 for _, a := range arg2 { 758 varargs = append(varargs, a) 759 } 760 ret := m.ctrl.Call(m, "AssociateRouteTableWithContext", varargs...) 761 ret0, _ := ret[0].(*ec2.AssociateRouteTableOutput) 762 ret1, _ := ret[1].(error) 763 return ret0, ret1 764 } 765 766 // AssociateRouteTableWithContext indicates an expected call of AssociateRouteTableWithContext 767 func (mr *MockEC2APIMockRecorder) AssociateRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 768 mr.mock.ctrl.T.Helper() 769 varargs := append([]interface{}{arg0, arg1}, arg2...) 770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTableWithContext), varargs...) 771 } 772 773 // AssociateRouteTableRequest mocks base method 774 func (m *MockEC2API) AssociateRouteTableRequest(arg0 *ec2.AssociateRouteTableInput) (*request.Request, *ec2.AssociateRouteTableOutput) { 775 m.ctrl.T.Helper() 776 ret := m.ctrl.Call(m, "AssociateRouteTableRequest", arg0) 777 ret0, _ := ret[0].(*request.Request) 778 ret1, _ := ret[1].(*ec2.AssociateRouteTableOutput) 779 return ret0, ret1 780 } 781 782 // AssociateRouteTableRequest indicates an expected call of AssociateRouteTableRequest 783 func (mr *MockEC2APIMockRecorder) AssociateRouteTableRequest(arg0 interface{}) *gomock.Call { 784 mr.mock.ctrl.T.Helper() 785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateRouteTableRequest), arg0) 786 } 787 788 // AssociateSubnetCidrBlock mocks base method 789 func (m *MockEC2API) AssociateSubnetCidrBlock(arg0 *ec2.AssociateSubnetCidrBlockInput) (*ec2.AssociateSubnetCidrBlockOutput, error) { 790 m.ctrl.T.Helper() 791 ret := m.ctrl.Call(m, "AssociateSubnetCidrBlock", arg0) 792 ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput) 793 ret1, _ := ret[1].(error) 794 return ret0, ret1 795 } 796 797 // AssociateSubnetCidrBlock indicates an expected call of AssociateSubnetCidrBlock 798 func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlock(arg0 interface{}) *gomock.Call { 799 mr.mock.ctrl.T.Helper() 800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlock), arg0) 801 } 802 803 // AssociateSubnetCidrBlockWithContext mocks base method 804 func (m *MockEC2API) AssociateSubnetCidrBlockWithContext(arg0 aws.Context, arg1 *ec2.AssociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateSubnetCidrBlockOutput, error) { 805 m.ctrl.T.Helper() 806 varargs := []interface{}{arg0, arg1} 807 for _, a := range arg2 { 808 varargs = append(varargs, a) 809 } 810 ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockWithContext", varargs...) 811 ret0, _ := ret[0].(*ec2.AssociateSubnetCidrBlockOutput) 812 ret1, _ := ret[1].(error) 813 return ret0, ret1 814 } 815 816 // AssociateSubnetCidrBlockWithContext indicates an expected call of AssociateSubnetCidrBlockWithContext 817 func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 818 mr.mock.ctrl.T.Helper() 819 varargs := append([]interface{}{arg0, arg1}, arg2...) 820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlockWithContext), varargs...) 821 } 822 823 // AssociateSubnetCidrBlockRequest mocks base method 824 func (m *MockEC2API) AssociateSubnetCidrBlockRequest(arg0 *ec2.AssociateSubnetCidrBlockInput) (*request.Request, *ec2.AssociateSubnetCidrBlockOutput) { 825 m.ctrl.T.Helper() 826 ret := m.ctrl.Call(m, "AssociateSubnetCidrBlockRequest", arg0) 827 ret0, _ := ret[0].(*request.Request) 828 ret1, _ := ret[1].(*ec2.AssociateSubnetCidrBlockOutput) 829 return ret0, ret1 830 } 831 832 // AssociateSubnetCidrBlockRequest indicates an expected call of AssociateSubnetCidrBlockRequest 833 func (mr *MockEC2APIMockRecorder) AssociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call { 834 mr.mock.ctrl.T.Helper() 835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateSubnetCidrBlockRequest), arg0) 836 } 837 838 // AssociateTransitGatewayRouteTable mocks base method 839 func (m *MockEC2API) AssociateTransitGatewayRouteTable(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*ec2.AssociateTransitGatewayRouteTableOutput, error) { 840 m.ctrl.T.Helper() 841 ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTable", arg0) 842 ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput) 843 ret1, _ := ret[1].(error) 844 return ret0, ret1 845 } 846 847 // AssociateTransitGatewayRouteTable indicates an expected call of AssociateTransitGatewayRouteTable 848 func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { 849 mr.mock.ctrl.T.Helper() 850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTable), arg0) 851 } 852 853 // AssociateTransitGatewayRouteTableWithContext mocks base method 854 func (m *MockEC2API) AssociateTransitGatewayRouteTableWithContext(arg0 aws.Context, arg1 *ec2.AssociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.AssociateTransitGatewayRouteTableOutput, error) { 855 m.ctrl.T.Helper() 856 varargs := []interface{}{arg0, arg1} 857 for _, a := range arg2 { 858 varargs = append(varargs, a) 859 } 860 ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableWithContext", varargs...) 861 ret0, _ := ret[0].(*ec2.AssociateTransitGatewayRouteTableOutput) 862 ret1, _ := ret[1].(error) 863 return ret0, ret1 864 } 865 866 // AssociateTransitGatewayRouteTableWithContext indicates an expected call of AssociateTransitGatewayRouteTableWithContext 867 func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 868 mr.mock.ctrl.T.Helper() 869 varargs := append([]interface{}{arg0, arg1}, arg2...) 870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableWithContext), varargs...) 871 } 872 873 // AssociateTransitGatewayRouteTableRequest mocks base method 874 func (m *MockEC2API) AssociateTransitGatewayRouteTableRequest(arg0 *ec2.AssociateTransitGatewayRouteTableInput) (*request.Request, *ec2.AssociateTransitGatewayRouteTableOutput) { 875 m.ctrl.T.Helper() 876 ret := m.ctrl.Call(m, "AssociateTransitGatewayRouteTableRequest", arg0) 877 ret0, _ := ret[0].(*request.Request) 878 ret1, _ := ret[1].(*ec2.AssociateTransitGatewayRouteTableOutput) 879 return ret0, ret1 880 } 881 882 // AssociateTransitGatewayRouteTableRequest indicates an expected call of AssociateTransitGatewayRouteTableRequest 883 func (mr *MockEC2APIMockRecorder) AssociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { 884 mr.mock.ctrl.T.Helper() 885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateTransitGatewayRouteTableRequest), arg0) 886 } 887 888 // AssociateVpcCidrBlock mocks base method 889 func (m *MockEC2API) AssociateVpcCidrBlock(arg0 *ec2.AssociateVpcCidrBlockInput) (*ec2.AssociateVpcCidrBlockOutput, error) { 890 m.ctrl.T.Helper() 891 ret := m.ctrl.Call(m, "AssociateVpcCidrBlock", arg0) 892 ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput) 893 ret1, _ := ret[1].(error) 894 return ret0, ret1 895 } 896 897 // AssociateVpcCidrBlock indicates an expected call of AssociateVpcCidrBlock 898 func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlock(arg0 interface{}) *gomock.Call { 899 mr.mock.ctrl.T.Helper() 900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlock), arg0) 901 } 902 903 // AssociateVpcCidrBlockWithContext mocks base method 904 func (m *MockEC2API) AssociateVpcCidrBlockWithContext(arg0 aws.Context, arg1 *ec2.AssociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.AssociateVpcCidrBlockOutput, error) { 905 m.ctrl.T.Helper() 906 varargs := []interface{}{arg0, arg1} 907 for _, a := range arg2 { 908 varargs = append(varargs, a) 909 } 910 ret := m.ctrl.Call(m, "AssociateVpcCidrBlockWithContext", varargs...) 911 ret0, _ := ret[0].(*ec2.AssociateVpcCidrBlockOutput) 912 ret1, _ := ret[1].(error) 913 return ret0, ret1 914 } 915 916 // AssociateVpcCidrBlockWithContext indicates an expected call of AssociateVpcCidrBlockWithContext 917 func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 918 mr.mock.ctrl.T.Helper() 919 varargs := append([]interface{}{arg0, arg1}, arg2...) 920 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlockWithContext), varargs...) 921 } 922 923 // AssociateVpcCidrBlockRequest mocks base method 924 func (m *MockEC2API) AssociateVpcCidrBlockRequest(arg0 *ec2.AssociateVpcCidrBlockInput) (*request.Request, *ec2.AssociateVpcCidrBlockOutput) { 925 m.ctrl.T.Helper() 926 ret := m.ctrl.Call(m, "AssociateVpcCidrBlockRequest", arg0) 927 ret0, _ := ret[0].(*request.Request) 928 ret1, _ := ret[1].(*ec2.AssociateVpcCidrBlockOutput) 929 return ret0, ret1 930 } 931 932 // AssociateVpcCidrBlockRequest indicates an expected call of AssociateVpcCidrBlockRequest 933 func (mr *MockEC2APIMockRecorder) AssociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call { 934 mr.mock.ctrl.T.Helper() 935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).AssociateVpcCidrBlockRequest), arg0) 936 } 937 938 // AttachClassicLinkVpc mocks base method 939 func (m *MockEC2API) AttachClassicLinkVpc(arg0 *ec2.AttachClassicLinkVpcInput) (*ec2.AttachClassicLinkVpcOutput, error) { 940 m.ctrl.T.Helper() 941 ret := m.ctrl.Call(m, "AttachClassicLinkVpc", arg0) 942 ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput) 943 ret1, _ := ret[1].(error) 944 return ret0, ret1 945 } 946 947 // AttachClassicLinkVpc indicates an expected call of AttachClassicLinkVpc 948 func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpc(arg0 interface{}) *gomock.Call { 949 mr.mock.ctrl.T.Helper() 950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpc), arg0) 951 } 952 953 // AttachClassicLinkVpcWithContext mocks base method 954 func (m *MockEC2API) AttachClassicLinkVpcWithContext(arg0 aws.Context, arg1 *ec2.AttachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.AttachClassicLinkVpcOutput, error) { 955 m.ctrl.T.Helper() 956 varargs := []interface{}{arg0, arg1} 957 for _, a := range arg2 { 958 varargs = append(varargs, a) 959 } 960 ret := m.ctrl.Call(m, "AttachClassicLinkVpcWithContext", varargs...) 961 ret0, _ := ret[0].(*ec2.AttachClassicLinkVpcOutput) 962 ret1, _ := ret[1].(error) 963 return ret0, ret1 964 } 965 966 // AttachClassicLinkVpcWithContext indicates an expected call of AttachClassicLinkVpcWithContext 967 func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 968 mr.mock.ctrl.T.Helper() 969 varargs := append([]interface{}{arg0, arg1}, arg2...) 970 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpcWithContext), varargs...) 971 } 972 973 // AttachClassicLinkVpcRequest mocks base method 974 func (m *MockEC2API) AttachClassicLinkVpcRequest(arg0 *ec2.AttachClassicLinkVpcInput) (*request.Request, *ec2.AttachClassicLinkVpcOutput) { 975 m.ctrl.T.Helper() 976 ret := m.ctrl.Call(m, "AttachClassicLinkVpcRequest", arg0) 977 ret0, _ := ret[0].(*request.Request) 978 ret1, _ := ret[1].(*ec2.AttachClassicLinkVpcOutput) 979 return ret0, ret1 980 } 981 982 // AttachClassicLinkVpcRequest indicates an expected call of AttachClassicLinkVpcRequest 983 func (mr *MockEC2APIMockRecorder) AttachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call { 984 mr.mock.ctrl.T.Helper() 985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).AttachClassicLinkVpcRequest), arg0) 986 } 987 988 // AttachInternetGateway mocks base method 989 func (m *MockEC2API) AttachInternetGateway(arg0 *ec2.AttachInternetGatewayInput) (*ec2.AttachInternetGatewayOutput, error) { 990 m.ctrl.T.Helper() 991 ret := m.ctrl.Call(m, "AttachInternetGateway", arg0) 992 ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput) 993 ret1, _ := ret[1].(error) 994 return ret0, ret1 995 } 996 997 // AttachInternetGateway indicates an expected call of AttachInternetGateway 998 func (mr *MockEC2APIMockRecorder) AttachInternetGateway(arg0 interface{}) *gomock.Call { 999 mr.mock.ctrl.T.Helper() 1000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGateway), arg0) 1001 } 1002 1003 // AttachInternetGatewayWithContext mocks base method 1004 func (m *MockEC2API) AttachInternetGatewayWithContext(arg0 aws.Context, arg1 *ec2.AttachInternetGatewayInput, arg2 ...request.Option) (*ec2.AttachInternetGatewayOutput, error) { 1005 m.ctrl.T.Helper() 1006 varargs := []interface{}{arg0, arg1} 1007 for _, a := range arg2 { 1008 varargs = append(varargs, a) 1009 } 1010 ret := m.ctrl.Call(m, "AttachInternetGatewayWithContext", varargs...) 1011 ret0, _ := ret[0].(*ec2.AttachInternetGatewayOutput) 1012 ret1, _ := ret[1].(error) 1013 return ret0, ret1 1014 } 1015 1016 // AttachInternetGatewayWithContext indicates an expected call of AttachInternetGatewayWithContext 1017 func (mr *MockEC2APIMockRecorder) AttachInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1018 mr.mock.ctrl.T.Helper() 1019 varargs := append([]interface{}{arg0, arg1}, arg2...) 1020 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGatewayWithContext), varargs...) 1021 } 1022 1023 // AttachInternetGatewayRequest mocks base method 1024 func (m *MockEC2API) AttachInternetGatewayRequest(arg0 *ec2.AttachInternetGatewayInput) (*request.Request, *ec2.AttachInternetGatewayOutput) { 1025 m.ctrl.T.Helper() 1026 ret := m.ctrl.Call(m, "AttachInternetGatewayRequest", arg0) 1027 ret0, _ := ret[0].(*request.Request) 1028 ret1, _ := ret[1].(*ec2.AttachInternetGatewayOutput) 1029 return ret0, ret1 1030 } 1031 1032 // AttachInternetGatewayRequest indicates an expected call of AttachInternetGatewayRequest 1033 func (mr *MockEC2APIMockRecorder) AttachInternetGatewayRequest(arg0 interface{}) *gomock.Call { 1034 mr.mock.ctrl.T.Helper() 1035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachInternetGatewayRequest), arg0) 1036 } 1037 1038 // AttachNetworkInterface mocks base method 1039 func (m *MockEC2API) AttachNetworkInterface(arg0 *ec2.AttachNetworkInterfaceInput) (*ec2.AttachNetworkInterfaceOutput, error) { 1040 m.ctrl.T.Helper() 1041 ret := m.ctrl.Call(m, "AttachNetworkInterface", arg0) 1042 ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput) 1043 ret1, _ := ret[1].(error) 1044 return ret0, ret1 1045 } 1046 1047 // AttachNetworkInterface indicates an expected call of AttachNetworkInterface 1048 func (mr *MockEC2APIMockRecorder) AttachNetworkInterface(arg0 interface{}) *gomock.Call { 1049 mr.mock.ctrl.T.Helper() 1050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterface), arg0) 1051 } 1052 1053 // AttachNetworkInterfaceWithContext mocks base method 1054 func (m *MockEC2API) AttachNetworkInterfaceWithContext(arg0 aws.Context, arg1 *ec2.AttachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.AttachNetworkInterfaceOutput, error) { 1055 m.ctrl.T.Helper() 1056 varargs := []interface{}{arg0, arg1} 1057 for _, a := range arg2 { 1058 varargs = append(varargs, a) 1059 } 1060 ret := m.ctrl.Call(m, "AttachNetworkInterfaceWithContext", varargs...) 1061 ret0, _ := ret[0].(*ec2.AttachNetworkInterfaceOutput) 1062 ret1, _ := ret[1].(error) 1063 return ret0, ret1 1064 } 1065 1066 // AttachNetworkInterfaceWithContext indicates an expected call of AttachNetworkInterfaceWithContext 1067 func (mr *MockEC2APIMockRecorder) AttachNetworkInterfaceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1068 mr.mock.ctrl.T.Helper() 1069 varargs := append([]interface{}{arg0, arg1}, arg2...) 1070 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterfaceWithContext), varargs...) 1071 } 1072 1073 // AttachNetworkInterfaceRequest mocks base method 1074 func (m *MockEC2API) AttachNetworkInterfaceRequest(arg0 *ec2.AttachNetworkInterfaceInput) (*request.Request, *ec2.AttachNetworkInterfaceOutput) { 1075 m.ctrl.T.Helper() 1076 ret := m.ctrl.Call(m, "AttachNetworkInterfaceRequest", arg0) 1077 ret0, _ := ret[0].(*request.Request) 1078 ret1, _ := ret[1].(*ec2.AttachNetworkInterfaceOutput) 1079 return ret0, ret1 1080 } 1081 1082 // AttachNetworkInterfaceRequest indicates an expected call of AttachNetworkInterfaceRequest 1083 func (mr *MockEC2APIMockRecorder) AttachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { 1084 mr.mock.ctrl.T.Helper() 1085 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).AttachNetworkInterfaceRequest), arg0) 1086 } 1087 1088 // AttachVolume mocks base method 1089 func (m *MockEC2API) AttachVolume(arg0 *ec2.AttachVolumeInput) (*ec2.VolumeAttachment, error) { 1090 m.ctrl.T.Helper() 1091 ret := m.ctrl.Call(m, "AttachVolume", arg0) 1092 ret0, _ := ret[0].(*ec2.VolumeAttachment) 1093 ret1, _ := ret[1].(error) 1094 return ret0, ret1 1095 } 1096 1097 // AttachVolume indicates an expected call of AttachVolume 1098 func (mr *MockEC2APIMockRecorder) AttachVolume(arg0 interface{}) *gomock.Call { 1099 mr.mock.ctrl.T.Helper() 1100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolume", reflect.TypeOf((*MockEC2API)(nil).AttachVolume), arg0) 1101 } 1102 1103 // AttachVolumeWithContext mocks base method 1104 func (m *MockEC2API) AttachVolumeWithContext(arg0 aws.Context, arg1 *ec2.AttachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) { 1105 m.ctrl.T.Helper() 1106 varargs := []interface{}{arg0, arg1} 1107 for _, a := range arg2 { 1108 varargs = append(varargs, a) 1109 } 1110 ret := m.ctrl.Call(m, "AttachVolumeWithContext", varargs...) 1111 ret0, _ := ret[0].(*ec2.VolumeAttachment) 1112 ret1, _ := ret[1].(error) 1113 return ret0, ret1 1114 } 1115 1116 // AttachVolumeWithContext indicates an expected call of AttachVolumeWithContext 1117 func (mr *MockEC2APIMockRecorder) AttachVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1118 mr.mock.ctrl.T.Helper() 1119 varargs := append([]interface{}{arg0, arg1}, arg2...) 1120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachVolumeWithContext), varargs...) 1121 } 1122 1123 // AttachVolumeRequest mocks base method 1124 func (m *MockEC2API) AttachVolumeRequest(arg0 *ec2.AttachVolumeInput) (*request.Request, *ec2.VolumeAttachment) { 1125 m.ctrl.T.Helper() 1126 ret := m.ctrl.Call(m, "AttachVolumeRequest", arg0) 1127 ret0, _ := ret[0].(*request.Request) 1128 ret1, _ := ret[1].(*ec2.VolumeAttachment) 1129 return ret0, ret1 1130 } 1131 1132 // AttachVolumeRequest indicates an expected call of AttachVolumeRequest 1133 func (mr *MockEC2APIMockRecorder) AttachVolumeRequest(arg0 interface{}) *gomock.Call { 1134 mr.mock.ctrl.T.Helper() 1135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVolumeRequest), arg0) 1136 } 1137 1138 // AttachVpnGateway mocks base method 1139 func (m *MockEC2API) AttachVpnGateway(arg0 *ec2.AttachVpnGatewayInput) (*ec2.AttachVpnGatewayOutput, error) { 1140 m.ctrl.T.Helper() 1141 ret := m.ctrl.Call(m, "AttachVpnGateway", arg0) 1142 ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput) 1143 ret1, _ := ret[1].(error) 1144 return ret0, ret1 1145 } 1146 1147 // AttachVpnGateway indicates an expected call of AttachVpnGateway 1148 func (mr *MockEC2APIMockRecorder) AttachVpnGateway(arg0 interface{}) *gomock.Call { 1149 mr.mock.ctrl.T.Helper() 1150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGateway), arg0) 1151 } 1152 1153 // AttachVpnGatewayWithContext mocks base method 1154 func (m *MockEC2API) AttachVpnGatewayWithContext(arg0 aws.Context, arg1 *ec2.AttachVpnGatewayInput, arg2 ...request.Option) (*ec2.AttachVpnGatewayOutput, error) { 1155 m.ctrl.T.Helper() 1156 varargs := []interface{}{arg0, arg1} 1157 for _, a := range arg2 { 1158 varargs = append(varargs, a) 1159 } 1160 ret := m.ctrl.Call(m, "AttachVpnGatewayWithContext", varargs...) 1161 ret0, _ := ret[0].(*ec2.AttachVpnGatewayOutput) 1162 ret1, _ := ret[1].(error) 1163 return ret0, ret1 1164 } 1165 1166 // AttachVpnGatewayWithContext indicates an expected call of AttachVpnGatewayWithContext 1167 func (mr *MockEC2APIMockRecorder) AttachVpnGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1168 mr.mock.ctrl.T.Helper() 1169 varargs := append([]interface{}{arg0, arg1}, arg2...) 1170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGatewayWithContext), varargs...) 1171 } 1172 1173 // AttachVpnGatewayRequest mocks base method 1174 func (m *MockEC2API) AttachVpnGatewayRequest(arg0 *ec2.AttachVpnGatewayInput) (*request.Request, *ec2.AttachVpnGatewayOutput) { 1175 m.ctrl.T.Helper() 1176 ret := m.ctrl.Call(m, "AttachVpnGatewayRequest", arg0) 1177 ret0, _ := ret[0].(*request.Request) 1178 ret1, _ := ret[1].(*ec2.AttachVpnGatewayOutput) 1179 return ret0, ret1 1180 } 1181 1182 // AttachVpnGatewayRequest indicates an expected call of AttachVpnGatewayRequest 1183 func (mr *MockEC2APIMockRecorder) AttachVpnGatewayRequest(arg0 interface{}) *gomock.Call { 1184 mr.mock.ctrl.T.Helper() 1185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AttachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).AttachVpnGatewayRequest), arg0) 1186 } 1187 1188 // AuthorizeClientVpnIngress mocks base method 1189 func (m *MockEC2API) AuthorizeClientVpnIngress(arg0 *ec2.AuthorizeClientVpnIngressInput) (*ec2.AuthorizeClientVpnIngressOutput, error) { 1190 m.ctrl.T.Helper() 1191 ret := m.ctrl.Call(m, "AuthorizeClientVpnIngress", arg0) 1192 ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput) 1193 ret1, _ := ret[1].(error) 1194 return ret0, ret1 1195 } 1196 1197 // AuthorizeClientVpnIngress indicates an expected call of AuthorizeClientVpnIngress 1198 func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngress(arg0 interface{}) *gomock.Call { 1199 mr.mock.ctrl.T.Helper() 1200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngress), arg0) 1201 } 1202 1203 // AuthorizeClientVpnIngressWithContext mocks base method 1204 func (m *MockEC2API) AuthorizeClientVpnIngressWithContext(arg0 aws.Context, arg1 *ec2.AuthorizeClientVpnIngressInput, arg2 ...request.Option) (*ec2.AuthorizeClientVpnIngressOutput, error) { 1205 m.ctrl.T.Helper() 1206 varargs := []interface{}{arg0, arg1} 1207 for _, a := range arg2 { 1208 varargs = append(varargs, a) 1209 } 1210 ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressWithContext", varargs...) 1211 ret0, _ := ret[0].(*ec2.AuthorizeClientVpnIngressOutput) 1212 ret1, _ := ret[1].(error) 1213 return ret0, ret1 1214 } 1215 1216 // AuthorizeClientVpnIngressWithContext indicates an expected call of AuthorizeClientVpnIngressWithContext 1217 func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1218 mr.mock.ctrl.T.Helper() 1219 varargs := append([]interface{}{arg0, arg1}, arg2...) 1220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngressWithContext), varargs...) 1221 } 1222 1223 // AuthorizeClientVpnIngressRequest mocks base method 1224 func (m *MockEC2API) AuthorizeClientVpnIngressRequest(arg0 *ec2.AuthorizeClientVpnIngressInput) (*request.Request, *ec2.AuthorizeClientVpnIngressOutput) { 1225 m.ctrl.T.Helper() 1226 ret := m.ctrl.Call(m, "AuthorizeClientVpnIngressRequest", arg0) 1227 ret0, _ := ret[0].(*request.Request) 1228 ret1, _ := ret[1].(*ec2.AuthorizeClientVpnIngressOutput) 1229 return ret0, ret1 1230 } 1231 1232 // AuthorizeClientVpnIngressRequest indicates an expected call of AuthorizeClientVpnIngressRequest 1233 func (mr *MockEC2APIMockRecorder) AuthorizeClientVpnIngressRequest(arg0 interface{}) *gomock.Call { 1234 mr.mock.ctrl.T.Helper() 1235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeClientVpnIngressRequest), arg0) 1236 } 1237 1238 // AuthorizeSecurityGroupEgress mocks base method 1239 func (m *MockEC2API) AuthorizeSecurityGroupEgress(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*ec2.AuthorizeSecurityGroupEgressOutput, error) { 1240 m.ctrl.T.Helper() 1241 ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgress", arg0) 1242 ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput) 1243 ret1, _ := ret[1].(error) 1244 return ret0, ret1 1245 } 1246 1247 // AuthorizeSecurityGroupEgress indicates an expected call of AuthorizeSecurityGroupEgress 1248 func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgress(arg0 interface{}) *gomock.Call { 1249 mr.mock.ctrl.T.Helper() 1250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgress), arg0) 1251 } 1252 1253 // AuthorizeSecurityGroupEgressWithContext mocks base method 1254 func (m *MockEC2API) AuthorizeSecurityGroupEgressWithContext(arg0 aws.Context, arg1 *ec2.AuthorizeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupEgressOutput, error) { 1255 m.ctrl.T.Helper() 1256 varargs := []interface{}{arg0, arg1} 1257 for _, a := range arg2 { 1258 varargs = append(varargs, a) 1259 } 1260 ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressWithContext", varargs...) 1261 ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupEgressOutput) 1262 ret1, _ := ret[1].(error) 1263 return ret0, ret1 1264 } 1265 1266 // AuthorizeSecurityGroupEgressWithContext indicates an expected call of AuthorizeSecurityGroupEgressWithContext 1267 func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1268 mr.mock.ctrl.T.Helper() 1269 varargs := append([]interface{}{arg0, arg1}, arg2...) 1270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgressWithContext), varargs...) 1271 } 1272 1273 // AuthorizeSecurityGroupEgressRequest mocks base method 1274 func (m *MockEC2API) AuthorizeSecurityGroupEgressRequest(arg0 *ec2.AuthorizeSecurityGroupEgressInput) (*request.Request, *ec2.AuthorizeSecurityGroupEgressOutput) { 1275 m.ctrl.T.Helper() 1276 ret := m.ctrl.Call(m, "AuthorizeSecurityGroupEgressRequest", arg0) 1277 ret0, _ := ret[0].(*request.Request) 1278 ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupEgressOutput) 1279 return ret0, ret1 1280 } 1281 1282 // AuthorizeSecurityGroupEgressRequest indicates an expected call of AuthorizeSecurityGroupEgressRequest 1283 func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call { 1284 mr.mock.ctrl.T.Helper() 1285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupEgressRequest), arg0) 1286 } 1287 1288 // AuthorizeSecurityGroupIngress mocks base method 1289 func (m *MockEC2API) AuthorizeSecurityGroupIngress(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*ec2.AuthorizeSecurityGroupIngressOutput, error) { 1290 m.ctrl.T.Helper() 1291 ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngress", arg0) 1292 ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput) 1293 ret1, _ := ret[1].(error) 1294 return ret0, ret1 1295 } 1296 1297 // AuthorizeSecurityGroupIngress indicates an expected call of AuthorizeSecurityGroupIngress 1298 func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngress(arg0 interface{}) *gomock.Call { 1299 mr.mock.ctrl.T.Helper() 1300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngress), arg0) 1301 } 1302 1303 // AuthorizeSecurityGroupIngressWithContext mocks base method 1304 func (m *MockEC2API) AuthorizeSecurityGroupIngressWithContext(arg0 aws.Context, arg1 *ec2.AuthorizeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.AuthorizeSecurityGroupIngressOutput, error) { 1305 m.ctrl.T.Helper() 1306 varargs := []interface{}{arg0, arg1} 1307 for _, a := range arg2 { 1308 varargs = append(varargs, a) 1309 } 1310 ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressWithContext", varargs...) 1311 ret0, _ := ret[0].(*ec2.AuthorizeSecurityGroupIngressOutput) 1312 ret1, _ := ret[1].(error) 1313 return ret0, ret1 1314 } 1315 1316 // AuthorizeSecurityGroupIngressWithContext indicates an expected call of AuthorizeSecurityGroupIngressWithContext 1317 func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1318 mr.mock.ctrl.T.Helper() 1319 varargs := append([]interface{}{arg0, arg1}, arg2...) 1320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngressWithContext), varargs...) 1321 } 1322 1323 // AuthorizeSecurityGroupIngressRequest mocks base method 1324 func (m *MockEC2API) AuthorizeSecurityGroupIngressRequest(arg0 *ec2.AuthorizeSecurityGroupIngressInput) (*request.Request, *ec2.AuthorizeSecurityGroupIngressOutput) { 1325 m.ctrl.T.Helper() 1326 ret := m.ctrl.Call(m, "AuthorizeSecurityGroupIngressRequest", arg0) 1327 ret0, _ := ret[0].(*request.Request) 1328 ret1, _ := ret[1].(*ec2.AuthorizeSecurityGroupIngressOutput) 1329 return ret0, ret1 1330 } 1331 1332 // AuthorizeSecurityGroupIngressRequest indicates an expected call of AuthorizeSecurityGroupIngressRequest 1333 func (mr *MockEC2APIMockRecorder) AuthorizeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { 1334 mr.mock.ctrl.T.Helper() 1335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AuthorizeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).AuthorizeSecurityGroupIngressRequest), arg0) 1336 } 1337 1338 // BundleInstance mocks base method 1339 func (m *MockEC2API) BundleInstance(arg0 *ec2.BundleInstanceInput) (*ec2.BundleInstanceOutput, error) { 1340 m.ctrl.T.Helper() 1341 ret := m.ctrl.Call(m, "BundleInstance", arg0) 1342 ret0, _ := ret[0].(*ec2.BundleInstanceOutput) 1343 ret1, _ := ret[1].(error) 1344 return ret0, ret1 1345 } 1346 1347 // BundleInstance indicates an expected call of BundleInstance 1348 func (mr *MockEC2APIMockRecorder) BundleInstance(arg0 interface{}) *gomock.Call { 1349 mr.mock.ctrl.T.Helper() 1350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstance", reflect.TypeOf((*MockEC2API)(nil).BundleInstance), arg0) 1351 } 1352 1353 // BundleInstanceWithContext mocks base method 1354 func (m *MockEC2API) BundleInstanceWithContext(arg0 aws.Context, arg1 *ec2.BundleInstanceInput, arg2 ...request.Option) (*ec2.BundleInstanceOutput, error) { 1355 m.ctrl.T.Helper() 1356 varargs := []interface{}{arg0, arg1} 1357 for _, a := range arg2 { 1358 varargs = append(varargs, a) 1359 } 1360 ret := m.ctrl.Call(m, "BundleInstanceWithContext", varargs...) 1361 ret0, _ := ret[0].(*ec2.BundleInstanceOutput) 1362 ret1, _ := ret[1].(error) 1363 return ret0, ret1 1364 } 1365 1366 // BundleInstanceWithContext indicates an expected call of BundleInstanceWithContext 1367 func (mr *MockEC2APIMockRecorder) BundleInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1368 mr.mock.ctrl.T.Helper() 1369 varargs := append([]interface{}{arg0, arg1}, arg2...) 1370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).BundleInstanceWithContext), varargs...) 1371 } 1372 1373 // BundleInstanceRequest mocks base method 1374 func (m *MockEC2API) BundleInstanceRequest(arg0 *ec2.BundleInstanceInput) (*request.Request, *ec2.BundleInstanceOutput) { 1375 m.ctrl.T.Helper() 1376 ret := m.ctrl.Call(m, "BundleInstanceRequest", arg0) 1377 ret0, _ := ret[0].(*request.Request) 1378 ret1, _ := ret[1].(*ec2.BundleInstanceOutput) 1379 return ret0, ret1 1380 } 1381 1382 // BundleInstanceRequest indicates an expected call of BundleInstanceRequest 1383 func (mr *MockEC2APIMockRecorder) BundleInstanceRequest(arg0 interface{}) *gomock.Call { 1384 mr.mock.ctrl.T.Helper() 1385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BundleInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).BundleInstanceRequest), arg0) 1386 } 1387 1388 // CancelBundleTask mocks base method 1389 func (m *MockEC2API) CancelBundleTask(arg0 *ec2.CancelBundleTaskInput) (*ec2.CancelBundleTaskOutput, error) { 1390 m.ctrl.T.Helper() 1391 ret := m.ctrl.Call(m, "CancelBundleTask", arg0) 1392 ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput) 1393 ret1, _ := ret[1].(error) 1394 return ret0, ret1 1395 } 1396 1397 // CancelBundleTask indicates an expected call of CancelBundleTask 1398 func (mr *MockEC2APIMockRecorder) CancelBundleTask(arg0 interface{}) *gomock.Call { 1399 mr.mock.ctrl.T.Helper() 1400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTask", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTask), arg0) 1401 } 1402 1403 // CancelBundleTaskWithContext mocks base method 1404 func (m *MockEC2API) CancelBundleTaskWithContext(arg0 aws.Context, arg1 *ec2.CancelBundleTaskInput, arg2 ...request.Option) (*ec2.CancelBundleTaskOutput, error) { 1405 m.ctrl.T.Helper() 1406 varargs := []interface{}{arg0, arg1} 1407 for _, a := range arg2 { 1408 varargs = append(varargs, a) 1409 } 1410 ret := m.ctrl.Call(m, "CancelBundleTaskWithContext", varargs...) 1411 ret0, _ := ret[0].(*ec2.CancelBundleTaskOutput) 1412 ret1, _ := ret[1].(error) 1413 return ret0, ret1 1414 } 1415 1416 // CancelBundleTaskWithContext indicates an expected call of CancelBundleTaskWithContext 1417 func (mr *MockEC2APIMockRecorder) CancelBundleTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1418 mr.mock.ctrl.T.Helper() 1419 varargs := append([]interface{}{arg0, arg1}, arg2...) 1420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTaskWithContext), varargs...) 1421 } 1422 1423 // CancelBundleTaskRequest mocks base method 1424 func (m *MockEC2API) CancelBundleTaskRequest(arg0 *ec2.CancelBundleTaskInput) (*request.Request, *ec2.CancelBundleTaskOutput) { 1425 m.ctrl.T.Helper() 1426 ret := m.ctrl.Call(m, "CancelBundleTaskRequest", arg0) 1427 ret0, _ := ret[0].(*request.Request) 1428 ret1, _ := ret[1].(*ec2.CancelBundleTaskOutput) 1429 return ret0, ret1 1430 } 1431 1432 // CancelBundleTaskRequest indicates an expected call of CancelBundleTaskRequest 1433 func (mr *MockEC2APIMockRecorder) CancelBundleTaskRequest(arg0 interface{}) *gomock.Call { 1434 mr.mock.ctrl.T.Helper() 1435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelBundleTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelBundleTaskRequest), arg0) 1436 } 1437 1438 // CancelCapacityReservation mocks base method 1439 func (m *MockEC2API) CancelCapacityReservation(arg0 *ec2.CancelCapacityReservationInput) (*ec2.CancelCapacityReservationOutput, error) { 1440 m.ctrl.T.Helper() 1441 ret := m.ctrl.Call(m, "CancelCapacityReservation", arg0) 1442 ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput) 1443 ret1, _ := ret[1].(error) 1444 return ret0, ret1 1445 } 1446 1447 // CancelCapacityReservation indicates an expected call of CancelCapacityReservation 1448 func (mr *MockEC2APIMockRecorder) CancelCapacityReservation(arg0 interface{}) *gomock.Call { 1449 mr.mock.ctrl.T.Helper() 1450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservation), arg0) 1451 } 1452 1453 // CancelCapacityReservationWithContext mocks base method 1454 func (m *MockEC2API) CancelCapacityReservationWithContext(arg0 aws.Context, arg1 *ec2.CancelCapacityReservationInput, arg2 ...request.Option) (*ec2.CancelCapacityReservationOutput, error) { 1455 m.ctrl.T.Helper() 1456 varargs := []interface{}{arg0, arg1} 1457 for _, a := range arg2 { 1458 varargs = append(varargs, a) 1459 } 1460 ret := m.ctrl.Call(m, "CancelCapacityReservationWithContext", varargs...) 1461 ret0, _ := ret[0].(*ec2.CancelCapacityReservationOutput) 1462 ret1, _ := ret[1].(error) 1463 return ret0, ret1 1464 } 1465 1466 // CancelCapacityReservationWithContext indicates an expected call of CancelCapacityReservationWithContext 1467 func (mr *MockEC2APIMockRecorder) CancelCapacityReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1468 mr.mock.ctrl.T.Helper() 1469 varargs := append([]interface{}{arg0, arg1}, arg2...) 1470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationWithContext), varargs...) 1471 } 1472 1473 // CancelCapacityReservationRequest mocks base method 1474 func (m *MockEC2API) CancelCapacityReservationRequest(arg0 *ec2.CancelCapacityReservationInput) (*request.Request, *ec2.CancelCapacityReservationOutput) { 1475 m.ctrl.T.Helper() 1476 ret := m.ctrl.Call(m, "CancelCapacityReservationRequest", arg0) 1477 ret0, _ := ret[0].(*request.Request) 1478 ret1, _ := ret[1].(*ec2.CancelCapacityReservationOutput) 1479 return ret0, ret1 1480 } 1481 1482 // CancelCapacityReservationRequest indicates an expected call of CancelCapacityReservationRequest 1483 func (mr *MockEC2APIMockRecorder) CancelCapacityReservationRequest(arg0 interface{}) *gomock.Call { 1484 mr.mock.ctrl.T.Helper() 1485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CancelCapacityReservationRequest), arg0) 1486 } 1487 1488 // CancelConversionTask mocks base method 1489 func (m *MockEC2API) CancelConversionTask(arg0 *ec2.CancelConversionTaskInput) (*ec2.CancelConversionTaskOutput, error) { 1490 m.ctrl.T.Helper() 1491 ret := m.ctrl.Call(m, "CancelConversionTask", arg0) 1492 ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput) 1493 ret1, _ := ret[1].(error) 1494 return ret0, ret1 1495 } 1496 1497 // CancelConversionTask indicates an expected call of CancelConversionTask 1498 func (mr *MockEC2APIMockRecorder) CancelConversionTask(arg0 interface{}) *gomock.Call { 1499 mr.mock.ctrl.T.Helper() 1500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTask", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTask), arg0) 1501 } 1502 1503 // CancelConversionTaskWithContext mocks base method 1504 func (m *MockEC2API) CancelConversionTaskWithContext(arg0 aws.Context, arg1 *ec2.CancelConversionTaskInput, arg2 ...request.Option) (*ec2.CancelConversionTaskOutput, error) { 1505 m.ctrl.T.Helper() 1506 varargs := []interface{}{arg0, arg1} 1507 for _, a := range arg2 { 1508 varargs = append(varargs, a) 1509 } 1510 ret := m.ctrl.Call(m, "CancelConversionTaskWithContext", varargs...) 1511 ret0, _ := ret[0].(*ec2.CancelConversionTaskOutput) 1512 ret1, _ := ret[1].(error) 1513 return ret0, ret1 1514 } 1515 1516 // CancelConversionTaskWithContext indicates an expected call of CancelConversionTaskWithContext 1517 func (mr *MockEC2APIMockRecorder) CancelConversionTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1518 mr.mock.ctrl.T.Helper() 1519 varargs := append([]interface{}{arg0, arg1}, arg2...) 1520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTaskWithContext), varargs...) 1521 } 1522 1523 // CancelConversionTaskRequest mocks base method 1524 func (m *MockEC2API) CancelConversionTaskRequest(arg0 *ec2.CancelConversionTaskInput) (*request.Request, *ec2.CancelConversionTaskOutput) { 1525 m.ctrl.T.Helper() 1526 ret := m.ctrl.Call(m, "CancelConversionTaskRequest", arg0) 1527 ret0, _ := ret[0].(*request.Request) 1528 ret1, _ := ret[1].(*ec2.CancelConversionTaskOutput) 1529 return ret0, ret1 1530 } 1531 1532 // CancelConversionTaskRequest indicates an expected call of CancelConversionTaskRequest 1533 func (mr *MockEC2APIMockRecorder) CancelConversionTaskRequest(arg0 interface{}) *gomock.Call { 1534 mr.mock.ctrl.T.Helper() 1535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelConversionTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelConversionTaskRequest), arg0) 1536 } 1537 1538 // CancelExportTask mocks base method 1539 func (m *MockEC2API) CancelExportTask(arg0 *ec2.CancelExportTaskInput) (*ec2.CancelExportTaskOutput, error) { 1540 m.ctrl.T.Helper() 1541 ret := m.ctrl.Call(m, "CancelExportTask", arg0) 1542 ret0, _ := ret[0].(*ec2.CancelExportTaskOutput) 1543 ret1, _ := ret[1].(error) 1544 return ret0, ret1 1545 } 1546 1547 // CancelExportTask indicates an expected call of CancelExportTask 1548 func (mr *MockEC2APIMockRecorder) CancelExportTask(arg0 interface{}) *gomock.Call { 1549 mr.mock.ctrl.T.Helper() 1550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTask", reflect.TypeOf((*MockEC2API)(nil).CancelExportTask), arg0) 1551 } 1552 1553 // CancelExportTaskWithContext mocks base method 1554 func (m *MockEC2API) CancelExportTaskWithContext(arg0 aws.Context, arg1 *ec2.CancelExportTaskInput, arg2 ...request.Option) (*ec2.CancelExportTaskOutput, error) { 1555 m.ctrl.T.Helper() 1556 varargs := []interface{}{arg0, arg1} 1557 for _, a := range arg2 { 1558 varargs = append(varargs, a) 1559 } 1560 ret := m.ctrl.Call(m, "CancelExportTaskWithContext", varargs...) 1561 ret0, _ := ret[0].(*ec2.CancelExportTaskOutput) 1562 ret1, _ := ret[1].(error) 1563 return ret0, ret1 1564 } 1565 1566 // CancelExportTaskWithContext indicates an expected call of CancelExportTaskWithContext 1567 func (mr *MockEC2APIMockRecorder) CancelExportTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1568 mr.mock.ctrl.T.Helper() 1569 varargs := append([]interface{}{arg0, arg1}, arg2...) 1570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelExportTaskWithContext), varargs...) 1571 } 1572 1573 // CancelExportTaskRequest mocks base method 1574 func (m *MockEC2API) CancelExportTaskRequest(arg0 *ec2.CancelExportTaskInput) (*request.Request, *ec2.CancelExportTaskOutput) { 1575 m.ctrl.T.Helper() 1576 ret := m.ctrl.Call(m, "CancelExportTaskRequest", arg0) 1577 ret0, _ := ret[0].(*request.Request) 1578 ret1, _ := ret[1].(*ec2.CancelExportTaskOutput) 1579 return ret0, ret1 1580 } 1581 1582 // CancelExportTaskRequest indicates an expected call of CancelExportTaskRequest 1583 func (mr *MockEC2APIMockRecorder) CancelExportTaskRequest(arg0 interface{}) *gomock.Call { 1584 mr.mock.ctrl.T.Helper() 1585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelExportTaskRequest), arg0) 1586 } 1587 1588 // CancelImportTask mocks base method 1589 func (m *MockEC2API) CancelImportTask(arg0 *ec2.CancelImportTaskInput) (*ec2.CancelImportTaskOutput, error) { 1590 m.ctrl.T.Helper() 1591 ret := m.ctrl.Call(m, "CancelImportTask", arg0) 1592 ret0, _ := ret[0].(*ec2.CancelImportTaskOutput) 1593 ret1, _ := ret[1].(error) 1594 return ret0, ret1 1595 } 1596 1597 // CancelImportTask indicates an expected call of CancelImportTask 1598 func (mr *MockEC2APIMockRecorder) CancelImportTask(arg0 interface{}) *gomock.Call { 1599 mr.mock.ctrl.T.Helper() 1600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTask", reflect.TypeOf((*MockEC2API)(nil).CancelImportTask), arg0) 1601 } 1602 1603 // CancelImportTaskWithContext mocks base method 1604 func (m *MockEC2API) CancelImportTaskWithContext(arg0 aws.Context, arg1 *ec2.CancelImportTaskInput, arg2 ...request.Option) (*ec2.CancelImportTaskOutput, error) { 1605 m.ctrl.T.Helper() 1606 varargs := []interface{}{arg0, arg1} 1607 for _, a := range arg2 { 1608 varargs = append(varargs, a) 1609 } 1610 ret := m.ctrl.Call(m, "CancelImportTaskWithContext", varargs...) 1611 ret0, _ := ret[0].(*ec2.CancelImportTaskOutput) 1612 ret1, _ := ret[1].(error) 1613 return ret0, ret1 1614 } 1615 1616 // CancelImportTaskWithContext indicates an expected call of CancelImportTaskWithContext 1617 func (mr *MockEC2APIMockRecorder) CancelImportTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1618 mr.mock.ctrl.T.Helper() 1619 varargs := append([]interface{}{arg0, arg1}, arg2...) 1620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelImportTaskWithContext), varargs...) 1621 } 1622 1623 // CancelImportTaskRequest mocks base method 1624 func (m *MockEC2API) CancelImportTaskRequest(arg0 *ec2.CancelImportTaskInput) (*request.Request, *ec2.CancelImportTaskOutput) { 1625 m.ctrl.T.Helper() 1626 ret := m.ctrl.Call(m, "CancelImportTaskRequest", arg0) 1627 ret0, _ := ret[0].(*request.Request) 1628 ret1, _ := ret[1].(*ec2.CancelImportTaskOutput) 1629 return ret0, ret1 1630 } 1631 1632 // CancelImportTaskRequest indicates an expected call of CancelImportTaskRequest 1633 func (mr *MockEC2APIMockRecorder) CancelImportTaskRequest(arg0 interface{}) *gomock.Call { 1634 mr.mock.ctrl.T.Helper() 1635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelImportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CancelImportTaskRequest), arg0) 1636 } 1637 1638 // CancelReservedInstancesListing mocks base method 1639 func (m *MockEC2API) CancelReservedInstancesListing(arg0 *ec2.CancelReservedInstancesListingInput) (*ec2.CancelReservedInstancesListingOutput, error) { 1640 m.ctrl.T.Helper() 1641 ret := m.ctrl.Call(m, "CancelReservedInstancesListing", arg0) 1642 ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput) 1643 ret1, _ := ret[1].(error) 1644 return ret0, ret1 1645 } 1646 1647 // CancelReservedInstancesListing indicates an expected call of CancelReservedInstancesListing 1648 func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListing(arg0 interface{}) *gomock.Call { 1649 mr.mock.ctrl.T.Helper() 1650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListing), arg0) 1651 } 1652 1653 // CancelReservedInstancesListingWithContext mocks base method 1654 func (m *MockEC2API) CancelReservedInstancesListingWithContext(arg0 aws.Context, arg1 *ec2.CancelReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CancelReservedInstancesListingOutput, error) { 1655 m.ctrl.T.Helper() 1656 varargs := []interface{}{arg0, arg1} 1657 for _, a := range arg2 { 1658 varargs = append(varargs, a) 1659 } 1660 ret := m.ctrl.Call(m, "CancelReservedInstancesListingWithContext", varargs...) 1661 ret0, _ := ret[0].(*ec2.CancelReservedInstancesListingOutput) 1662 ret1, _ := ret[1].(error) 1663 return ret0, ret1 1664 } 1665 1666 // CancelReservedInstancesListingWithContext indicates an expected call of CancelReservedInstancesListingWithContext 1667 func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1668 mr.mock.ctrl.T.Helper() 1669 varargs := append([]interface{}{arg0, arg1}, arg2...) 1670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListingWithContext), varargs...) 1671 } 1672 1673 // CancelReservedInstancesListingRequest mocks base method 1674 func (m *MockEC2API) CancelReservedInstancesListingRequest(arg0 *ec2.CancelReservedInstancesListingInput) (*request.Request, *ec2.CancelReservedInstancesListingOutput) { 1675 m.ctrl.T.Helper() 1676 ret := m.ctrl.Call(m, "CancelReservedInstancesListingRequest", arg0) 1677 ret0, _ := ret[0].(*request.Request) 1678 ret1, _ := ret[1].(*ec2.CancelReservedInstancesListingOutput) 1679 return ret0, ret1 1680 } 1681 1682 // CancelReservedInstancesListingRequest indicates an expected call of CancelReservedInstancesListingRequest 1683 func (mr *MockEC2APIMockRecorder) CancelReservedInstancesListingRequest(arg0 interface{}) *gomock.Call { 1684 mr.mock.ctrl.T.Helper() 1685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CancelReservedInstancesListingRequest), arg0) 1686 } 1687 1688 // CancelSpotFleetRequests mocks base method 1689 func (m *MockEC2API) CancelSpotFleetRequests(arg0 *ec2.CancelSpotFleetRequestsInput) (*ec2.CancelSpotFleetRequestsOutput, error) { 1690 m.ctrl.T.Helper() 1691 ret := m.ctrl.Call(m, "CancelSpotFleetRequests", arg0) 1692 ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput) 1693 ret1, _ := ret[1].(error) 1694 return ret0, ret1 1695 } 1696 1697 // CancelSpotFleetRequests indicates an expected call of CancelSpotFleetRequests 1698 func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequests(arg0 interface{}) *gomock.Call { 1699 mr.mock.ctrl.T.Helper() 1700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequests), arg0) 1701 } 1702 1703 // CancelSpotFleetRequestsWithContext mocks base method 1704 func (m *MockEC2API) CancelSpotFleetRequestsWithContext(arg0 aws.Context, arg1 *ec2.CancelSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotFleetRequestsOutput, error) { 1705 m.ctrl.T.Helper() 1706 varargs := []interface{}{arg0, arg1} 1707 for _, a := range arg2 { 1708 varargs = append(varargs, a) 1709 } 1710 ret := m.ctrl.Call(m, "CancelSpotFleetRequestsWithContext", varargs...) 1711 ret0, _ := ret[0].(*ec2.CancelSpotFleetRequestsOutput) 1712 ret1, _ := ret[1].(error) 1713 return ret0, ret1 1714 } 1715 1716 // CancelSpotFleetRequestsWithContext indicates an expected call of CancelSpotFleetRequestsWithContext 1717 func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1718 mr.mock.ctrl.T.Helper() 1719 varargs := append([]interface{}{arg0, arg1}, arg2...) 1720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequestsWithContext), varargs...) 1721 } 1722 1723 // CancelSpotFleetRequestsRequest mocks base method 1724 func (m *MockEC2API) CancelSpotFleetRequestsRequest(arg0 *ec2.CancelSpotFleetRequestsInput) (*request.Request, *ec2.CancelSpotFleetRequestsOutput) { 1725 m.ctrl.T.Helper() 1726 ret := m.ctrl.Call(m, "CancelSpotFleetRequestsRequest", arg0) 1727 ret0, _ := ret[0].(*request.Request) 1728 ret1, _ := ret[1].(*ec2.CancelSpotFleetRequestsOutput) 1729 return ret0, ret1 1730 } 1731 1732 // CancelSpotFleetRequestsRequest indicates an expected call of CancelSpotFleetRequestsRequest 1733 func (mr *MockEC2APIMockRecorder) CancelSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call { 1734 mr.mock.ctrl.T.Helper() 1735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotFleetRequestsRequest), arg0) 1736 } 1737 1738 // CancelSpotInstanceRequests mocks base method 1739 func (m *MockEC2API) CancelSpotInstanceRequests(arg0 *ec2.CancelSpotInstanceRequestsInput) (*ec2.CancelSpotInstanceRequestsOutput, error) { 1740 m.ctrl.T.Helper() 1741 ret := m.ctrl.Call(m, "CancelSpotInstanceRequests", arg0) 1742 ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput) 1743 ret1, _ := ret[1].(error) 1744 return ret0, ret1 1745 } 1746 1747 // CancelSpotInstanceRequests indicates an expected call of CancelSpotInstanceRequests 1748 func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequests(arg0 interface{}) *gomock.Call { 1749 mr.mock.ctrl.T.Helper() 1750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequests), arg0) 1751 } 1752 1753 // CancelSpotInstanceRequestsWithContext mocks base method 1754 func (m *MockEC2API) CancelSpotInstanceRequestsWithContext(arg0 aws.Context, arg1 *ec2.CancelSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.CancelSpotInstanceRequestsOutput, error) { 1755 m.ctrl.T.Helper() 1756 varargs := []interface{}{arg0, arg1} 1757 for _, a := range arg2 { 1758 varargs = append(varargs, a) 1759 } 1760 ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsWithContext", varargs...) 1761 ret0, _ := ret[0].(*ec2.CancelSpotInstanceRequestsOutput) 1762 ret1, _ := ret[1].(error) 1763 return ret0, ret1 1764 } 1765 1766 // CancelSpotInstanceRequestsWithContext indicates an expected call of CancelSpotInstanceRequestsWithContext 1767 func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1768 mr.mock.ctrl.T.Helper() 1769 varargs := append([]interface{}{arg0, arg1}, arg2...) 1770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequestsWithContext), varargs...) 1771 } 1772 1773 // CancelSpotInstanceRequestsRequest mocks base method 1774 func (m *MockEC2API) CancelSpotInstanceRequestsRequest(arg0 *ec2.CancelSpotInstanceRequestsInput) (*request.Request, *ec2.CancelSpotInstanceRequestsOutput) { 1775 m.ctrl.T.Helper() 1776 ret := m.ctrl.Call(m, "CancelSpotInstanceRequestsRequest", arg0) 1777 ret0, _ := ret[0].(*request.Request) 1778 ret1, _ := ret[1].(*ec2.CancelSpotInstanceRequestsOutput) 1779 return ret0, ret1 1780 } 1781 1782 // CancelSpotInstanceRequestsRequest indicates an expected call of CancelSpotInstanceRequestsRequest 1783 func (mr *MockEC2APIMockRecorder) CancelSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call { 1784 mr.mock.ctrl.T.Helper() 1785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).CancelSpotInstanceRequestsRequest), arg0) 1786 } 1787 1788 // ConfirmProductInstance mocks base method 1789 func (m *MockEC2API) ConfirmProductInstance(arg0 *ec2.ConfirmProductInstanceInput) (*ec2.ConfirmProductInstanceOutput, error) { 1790 m.ctrl.T.Helper() 1791 ret := m.ctrl.Call(m, "ConfirmProductInstance", arg0) 1792 ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput) 1793 ret1, _ := ret[1].(error) 1794 return ret0, ret1 1795 } 1796 1797 // ConfirmProductInstance indicates an expected call of ConfirmProductInstance 1798 func (mr *MockEC2APIMockRecorder) ConfirmProductInstance(arg0 interface{}) *gomock.Call { 1799 mr.mock.ctrl.T.Helper() 1800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstance", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstance), arg0) 1801 } 1802 1803 // ConfirmProductInstanceWithContext mocks base method 1804 func (m *MockEC2API) ConfirmProductInstanceWithContext(arg0 aws.Context, arg1 *ec2.ConfirmProductInstanceInput, arg2 ...request.Option) (*ec2.ConfirmProductInstanceOutput, error) { 1805 m.ctrl.T.Helper() 1806 varargs := []interface{}{arg0, arg1} 1807 for _, a := range arg2 { 1808 varargs = append(varargs, a) 1809 } 1810 ret := m.ctrl.Call(m, "ConfirmProductInstanceWithContext", varargs...) 1811 ret0, _ := ret[0].(*ec2.ConfirmProductInstanceOutput) 1812 ret1, _ := ret[1].(error) 1813 return ret0, ret1 1814 } 1815 1816 // ConfirmProductInstanceWithContext indicates an expected call of ConfirmProductInstanceWithContext 1817 func (mr *MockEC2APIMockRecorder) ConfirmProductInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1818 mr.mock.ctrl.T.Helper() 1819 varargs := append([]interface{}{arg0, arg1}, arg2...) 1820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstanceWithContext), varargs...) 1821 } 1822 1823 // ConfirmProductInstanceRequest mocks base method 1824 func (m *MockEC2API) ConfirmProductInstanceRequest(arg0 *ec2.ConfirmProductInstanceInput) (*request.Request, *ec2.ConfirmProductInstanceOutput) { 1825 m.ctrl.T.Helper() 1826 ret := m.ctrl.Call(m, "ConfirmProductInstanceRequest", arg0) 1827 ret0, _ := ret[0].(*request.Request) 1828 ret1, _ := ret[1].(*ec2.ConfirmProductInstanceOutput) 1829 return ret0, ret1 1830 } 1831 1832 // ConfirmProductInstanceRequest indicates an expected call of ConfirmProductInstanceRequest 1833 func (mr *MockEC2APIMockRecorder) ConfirmProductInstanceRequest(arg0 interface{}) *gomock.Call { 1834 mr.mock.ctrl.T.Helper() 1835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConfirmProductInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ConfirmProductInstanceRequest), arg0) 1836 } 1837 1838 // CopyFpgaImage mocks base method 1839 func (m *MockEC2API) CopyFpgaImage(arg0 *ec2.CopyFpgaImageInput) (*ec2.CopyFpgaImageOutput, error) { 1840 m.ctrl.T.Helper() 1841 ret := m.ctrl.Call(m, "CopyFpgaImage", arg0) 1842 ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput) 1843 ret1, _ := ret[1].(error) 1844 return ret0, ret1 1845 } 1846 1847 // CopyFpgaImage indicates an expected call of CopyFpgaImage 1848 func (mr *MockEC2APIMockRecorder) CopyFpgaImage(arg0 interface{}) *gomock.Call { 1849 mr.mock.ctrl.T.Helper() 1850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImage), arg0) 1851 } 1852 1853 // CopyFpgaImageWithContext mocks base method 1854 func (m *MockEC2API) CopyFpgaImageWithContext(arg0 aws.Context, arg1 *ec2.CopyFpgaImageInput, arg2 ...request.Option) (*ec2.CopyFpgaImageOutput, error) { 1855 m.ctrl.T.Helper() 1856 varargs := []interface{}{arg0, arg1} 1857 for _, a := range arg2 { 1858 varargs = append(varargs, a) 1859 } 1860 ret := m.ctrl.Call(m, "CopyFpgaImageWithContext", varargs...) 1861 ret0, _ := ret[0].(*ec2.CopyFpgaImageOutput) 1862 ret1, _ := ret[1].(error) 1863 return ret0, ret1 1864 } 1865 1866 // CopyFpgaImageWithContext indicates an expected call of CopyFpgaImageWithContext 1867 func (mr *MockEC2APIMockRecorder) CopyFpgaImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1868 mr.mock.ctrl.T.Helper() 1869 varargs := append([]interface{}{arg0, arg1}, arg2...) 1870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImageWithContext), varargs...) 1871 } 1872 1873 // CopyFpgaImageRequest mocks base method 1874 func (m *MockEC2API) CopyFpgaImageRequest(arg0 *ec2.CopyFpgaImageInput) (*request.Request, *ec2.CopyFpgaImageOutput) { 1875 m.ctrl.T.Helper() 1876 ret := m.ctrl.Call(m, "CopyFpgaImageRequest", arg0) 1877 ret0, _ := ret[0].(*request.Request) 1878 ret1, _ := ret[1].(*ec2.CopyFpgaImageOutput) 1879 return ret0, ret1 1880 } 1881 1882 // CopyFpgaImageRequest indicates an expected call of CopyFpgaImageRequest 1883 func (mr *MockEC2APIMockRecorder) CopyFpgaImageRequest(arg0 interface{}) *gomock.Call { 1884 mr.mock.ctrl.T.Helper() 1885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyFpgaImageRequest), arg0) 1886 } 1887 1888 // CopyImage mocks base method 1889 func (m *MockEC2API) CopyImage(arg0 *ec2.CopyImageInput) (*ec2.CopyImageOutput, error) { 1890 m.ctrl.T.Helper() 1891 ret := m.ctrl.Call(m, "CopyImage", arg0) 1892 ret0, _ := ret[0].(*ec2.CopyImageOutput) 1893 ret1, _ := ret[1].(error) 1894 return ret0, ret1 1895 } 1896 1897 // CopyImage indicates an expected call of CopyImage 1898 func (mr *MockEC2APIMockRecorder) CopyImage(arg0 interface{}) *gomock.Call { 1899 mr.mock.ctrl.T.Helper() 1900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImage", reflect.TypeOf((*MockEC2API)(nil).CopyImage), arg0) 1901 } 1902 1903 // CopyImageWithContext mocks base method 1904 func (m *MockEC2API) CopyImageWithContext(arg0 aws.Context, arg1 *ec2.CopyImageInput, arg2 ...request.Option) (*ec2.CopyImageOutput, error) { 1905 m.ctrl.T.Helper() 1906 varargs := []interface{}{arg0, arg1} 1907 for _, a := range arg2 { 1908 varargs = append(varargs, a) 1909 } 1910 ret := m.ctrl.Call(m, "CopyImageWithContext", varargs...) 1911 ret0, _ := ret[0].(*ec2.CopyImageOutput) 1912 ret1, _ := ret[1].(error) 1913 return ret0, ret1 1914 } 1915 1916 // CopyImageWithContext indicates an expected call of CopyImageWithContext 1917 func (mr *MockEC2APIMockRecorder) CopyImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1918 mr.mock.ctrl.T.Helper() 1919 varargs := append([]interface{}{arg0, arg1}, arg2...) 1920 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CopyImageWithContext), varargs...) 1921 } 1922 1923 // CopyImageRequest mocks base method 1924 func (m *MockEC2API) CopyImageRequest(arg0 *ec2.CopyImageInput) (*request.Request, *ec2.CopyImageOutput) { 1925 m.ctrl.T.Helper() 1926 ret := m.ctrl.Call(m, "CopyImageRequest", arg0) 1927 ret0, _ := ret[0].(*request.Request) 1928 ret1, _ := ret[1].(*ec2.CopyImageOutput) 1929 return ret0, ret1 1930 } 1931 1932 // CopyImageRequest indicates an expected call of CopyImageRequest 1933 func (mr *MockEC2APIMockRecorder) CopyImageRequest(arg0 interface{}) *gomock.Call { 1934 mr.mock.ctrl.T.Helper() 1935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyImageRequest", reflect.TypeOf((*MockEC2API)(nil).CopyImageRequest), arg0) 1936 } 1937 1938 // CopySnapshot mocks base method 1939 func (m *MockEC2API) CopySnapshot(arg0 *ec2.CopySnapshotInput) (*ec2.CopySnapshotOutput, error) { 1940 m.ctrl.T.Helper() 1941 ret := m.ctrl.Call(m, "CopySnapshot", arg0) 1942 ret0, _ := ret[0].(*ec2.CopySnapshotOutput) 1943 ret1, _ := ret[1].(error) 1944 return ret0, ret1 1945 } 1946 1947 // CopySnapshot indicates an expected call of CopySnapshot 1948 func (mr *MockEC2APIMockRecorder) CopySnapshot(arg0 interface{}) *gomock.Call { 1949 mr.mock.ctrl.T.Helper() 1950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshot", reflect.TypeOf((*MockEC2API)(nil).CopySnapshot), arg0) 1951 } 1952 1953 // CopySnapshotWithContext mocks base method 1954 func (m *MockEC2API) CopySnapshotWithContext(arg0 aws.Context, arg1 *ec2.CopySnapshotInput, arg2 ...request.Option) (*ec2.CopySnapshotOutput, error) { 1955 m.ctrl.T.Helper() 1956 varargs := []interface{}{arg0, arg1} 1957 for _, a := range arg2 { 1958 varargs = append(varargs, a) 1959 } 1960 ret := m.ctrl.Call(m, "CopySnapshotWithContext", varargs...) 1961 ret0, _ := ret[0].(*ec2.CopySnapshotOutput) 1962 ret1, _ := ret[1].(error) 1963 return ret0, ret1 1964 } 1965 1966 // CopySnapshotWithContext indicates an expected call of CopySnapshotWithContext 1967 func (mr *MockEC2APIMockRecorder) CopySnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 1968 mr.mock.ctrl.T.Helper() 1969 varargs := append([]interface{}{arg0, arg1}, arg2...) 1970 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).CopySnapshotWithContext), varargs...) 1971 } 1972 1973 // CopySnapshotRequest mocks base method 1974 func (m *MockEC2API) CopySnapshotRequest(arg0 *ec2.CopySnapshotInput) (*request.Request, *ec2.CopySnapshotOutput) { 1975 m.ctrl.T.Helper() 1976 ret := m.ctrl.Call(m, "CopySnapshotRequest", arg0) 1977 ret0, _ := ret[0].(*request.Request) 1978 ret1, _ := ret[1].(*ec2.CopySnapshotOutput) 1979 return ret0, ret1 1980 } 1981 1982 // CopySnapshotRequest indicates an expected call of CopySnapshotRequest 1983 func (mr *MockEC2APIMockRecorder) CopySnapshotRequest(arg0 interface{}) *gomock.Call { 1984 mr.mock.ctrl.T.Helper() 1985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopySnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CopySnapshotRequest), arg0) 1986 } 1987 1988 // CreateCapacityReservation mocks base method 1989 func (m *MockEC2API) CreateCapacityReservation(arg0 *ec2.CreateCapacityReservationInput) (*ec2.CreateCapacityReservationOutput, error) { 1990 m.ctrl.T.Helper() 1991 ret := m.ctrl.Call(m, "CreateCapacityReservation", arg0) 1992 ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput) 1993 ret1, _ := ret[1].(error) 1994 return ret0, ret1 1995 } 1996 1997 // CreateCapacityReservation indicates an expected call of CreateCapacityReservation 1998 func (mr *MockEC2APIMockRecorder) CreateCapacityReservation(arg0 interface{}) *gomock.Call { 1999 mr.mock.ctrl.T.Helper() 2000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservation), arg0) 2001 } 2002 2003 // CreateCapacityReservationWithContext mocks base method 2004 func (m *MockEC2API) CreateCapacityReservationWithContext(arg0 aws.Context, arg1 *ec2.CreateCapacityReservationInput, arg2 ...request.Option) (*ec2.CreateCapacityReservationOutput, error) { 2005 m.ctrl.T.Helper() 2006 varargs := []interface{}{arg0, arg1} 2007 for _, a := range arg2 { 2008 varargs = append(varargs, a) 2009 } 2010 ret := m.ctrl.Call(m, "CreateCapacityReservationWithContext", varargs...) 2011 ret0, _ := ret[0].(*ec2.CreateCapacityReservationOutput) 2012 ret1, _ := ret[1].(error) 2013 return ret0, ret1 2014 } 2015 2016 // CreateCapacityReservationWithContext indicates an expected call of CreateCapacityReservationWithContext 2017 func (mr *MockEC2APIMockRecorder) CreateCapacityReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2018 mr.mock.ctrl.T.Helper() 2019 varargs := append([]interface{}{arg0, arg1}, arg2...) 2020 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationWithContext), varargs...) 2021 } 2022 2023 // CreateCapacityReservationRequest mocks base method 2024 func (m *MockEC2API) CreateCapacityReservationRequest(arg0 *ec2.CreateCapacityReservationInput) (*request.Request, *ec2.CreateCapacityReservationOutput) { 2025 m.ctrl.T.Helper() 2026 ret := m.ctrl.Call(m, "CreateCapacityReservationRequest", arg0) 2027 ret0, _ := ret[0].(*request.Request) 2028 ret1, _ := ret[1].(*ec2.CreateCapacityReservationOutput) 2029 return ret0, ret1 2030 } 2031 2032 // CreateCapacityReservationRequest indicates an expected call of CreateCapacityReservationRequest 2033 func (mr *MockEC2APIMockRecorder) CreateCapacityReservationRequest(arg0 interface{}) *gomock.Call { 2034 mr.mock.ctrl.T.Helper() 2035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCapacityReservationRequest), arg0) 2036 } 2037 2038 // CreateClientVpnEndpoint mocks base method 2039 func (m *MockEC2API) CreateClientVpnEndpoint(arg0 *ec2.CreateClientVpnEndpointInput) (*ec2.CreateClientVpnEndpointOutput, error) { 2040 m.ctrl.T.Helper() 2041 ret := m.ctrl.Call(m, "CreateClientVpnEndpoint", arg0) 2042 ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput) 2043 ret1, _ := ret[1].(error) 2044 return ret0, ret1 2045 } 2046 2047 // CreateClientVpnEndpoint indicates an expected call of CreateClientVpnEndpoint 2048 func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpoint(arg0 interface{}) *gomock.Call { 2049 mr.mock.ctrl.T.Helper() 2050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpoint), arg0) 2051 } 2052 2053 // CreateClientVpnEndpointWithContext mocks base method 2054 func (m *MockEC2API) CreateClientVpnEndpointWithContext(arg0 aws.Context, arg1 *ec2.CreateClientVpnEndpointInput, arg2 ...request.Option) (*ec2.CreateClientVpnEndpointOutput, error) { 2055 m.ctrl.T.Helper() 2056 varargs := []interface{}{arg0, arg1} 2057 for _, a := range arg2 { 2058 varargs = append(varargs, a) 2059 } 2060 ret := m.ctrl.Call(m, "CreateClientVpnEndpointWithContext", varargs...) 2061 ret0, _ := ret[0].(*ec2.CreateClientVpnEndpointOutput) 2062 ret1, _ := ret[1].(error) 2063 return ret0, ret1 2064 } 2065 2066 // CreateClientVpnEndpointWithContext indicates an expected call of CreateClientVpnEndpointWithContext 2067 func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2068 mr.mock.ctrl.T.Helper() 2069 varargs := append([]interface{}{arg0, arg1}, arg2...) 2070 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpointWithContext), varargs...) 2071 } 2072 2073 // CreateClientVpnEndpointRequest mocks base method 2074 func (m *MockEC2API) CreateClientVpnEndpointRequest(arg0 *ec2.CreateClientVpnEndpointInput) (*request.Request, *ec2.CreateClientVpnEndpointOutput) { 2075 m.ctrl.T.Helper() 2076 ret := m.ctrl.Call(m, "CreateClientVpnEndpointRequest", arg0) 2077 ret0, _ := ret[0].(*request.Request) 2078 ret1, _ := ret[1].(*ec2.CreateClientVpnEndpointOutput) 2079 return ret0, ret1 2080 } 2081 2082 // CreateClientVpnEndpointRequest indicates an expected call of CreateClientVpnEndpointRequest 2083 func (mr *MockEC2APIMockRecorder) CreateClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { 2084 mr.mock.ctrl.T.Helper() 2085 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnEndpointRequest), arg0) 2086 } 2087 2088 // CreateClientVpnRoute mocks base method 2089 func (m *MockEC2API) CreateClientVpnRoute(arg0 *ec2.CreateClientVpnRouteInput) (*ec2.CreateClientVpnRouteOutput, error) { 2090 m.ctrl.T.Helper() 2091 ret := m.ctrl.Call(m, "CreateClientVpnRoute", arg0) 2092 ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput) 2093 ret1, _ := ret[1].(error) 2094 return ret0, ret1 2095 } 2096 2097 // CreateClientVpnRoute indicates an expected call of CreateClientVpnRoute 2098 func (mr *MockEC2APIMockRecorder) CreateClientVpnRoute(arg0 interface{}) *gomock.Call { 2099 mr.mock.ctrl.T.Helper() 2100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRoute), arg0) 2101 } 2102 2103 // CreateClientVpnRouteWithContext mocks base method 2104 func (m *MockEC2API) CreateClientVpnRouteWithContext(arg0 aws.Context, arg1 *ec2.CreateClientVpnRouteInput, arg2 ...request.Option) (*ec2.CreateClientVpnRouteOutput, error) { 2105 m.ctrl.T.Helper() 2106 varargs := []interface{}{arg0, arg1} 2107 for _, a := range arg2 { 2108 varargs = append(varargs, a) 2109 } 2110 ret := m.ctrl.Call(m, "CreateClientVpnRouteWithContext", varargs...) 2111 ret0, _ := ret[0].(*ec2.CreateClientVpnRouteOutput) 2112 ret1, _ := ret[1].(error) 2113 return ret0, ret1 2114 } 2115 2116 // CreateClientVpnRouteWithContext indicates an expected call of CreateClientVpnRouteWithContext 2117 func (mr *MockEC2APIMockRecorder) CreateClientVpnRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2118 mr.mock.ctrl.T.Helper() 2119 varargs := append([]interface{}{arg0, arg1}, arg2...) 2120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRouteWithContext), varargs...) 2121 } 2122 2123 // CreateClientVpnRouteRequest mocks base method 2124 func (m *MockEC2API) CreateClientVpnRouteRequest(arg0 *ec2.CreateClientVpnRouteInput) (*request.Request, *ec2.CreateClientVpnRouteOutput) { 2125 m.ctrl.T.Helper() 2126 ret := m.ctrl.Call(m, "CreateClientVpnRouteRequest", arg0) 2127 ret0, _ := ret[0].(*request.Request) 2128 ret1, _ := ret[1].(*ec2.CreateClientVpnRouteOutput) 2129 return ret0, ret1 2130 } 2131 2132 // CreateClientVpnRouteRequest indicates an expected call of CreateClientVpnRouteRequest 2133 func (mr *MockEC2APIMockRecorder) CreateClientVpnRouteRequest(arg0 interface{}) *gomock.Call { 2134 mr.mock.ctrl.T.Helper() 2135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateClientVpnRouteRequest), arg0) 2136 } 2137 2138 // CreateCustomerGateway mocks base method 2139 func (m *MockEC2API) CreateCustomerGateway(arg0 *ec2.CreateCustomerGatewayInput) (*ec2.CreateCustomerGatewayOutput, error) { 2140 m.ctrl.T.Helper() 2141 ret := m.ctrl.Call(m, "CreateCustomerGateway", arg0) 2142 ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput) 2143 ret1, _ := ret[1].(error) 2144 return ret0, ret1 2145 } 2146 2147 // CreateCustomerGateway indicates an expected call of CreateCustomerGateway 2148 func (mr *MockEC2APIMockRecorder) CreateCustomerGateway(arg0 interface{}) *gomock.Call { 2149 mr.mock.ctrl.T.Helper() 2150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGateway), arg0) 2151 } 2152 2153 // CreateCustomerGatewayWithContext mocks base method 2154 func (m *MockEC2API) CreateCustomerGatewayWithContext(arg0 aws.Context, arg1 *ec2.CreateCustomerGatewayInput, arg2 ...request.Option) (*ec2.CreateCustomerGatewayOutput, error) { 2155 m.ctrl.T.Helper() 2156 varargs := []interface{}{arg0, arg1} 2157 for _, a := range arg2 { 2158 varargs = append(varargs, a) 2159 } 2160 ret := m.ctrl.Call(m, "CreateCustomerGatewayWithContext", varargs...) 2161 ret0, _ := ret[0].(*ec2.CreateCustomerGatewayOutput) 2162 ret1, _ := ret[1].(error) 2163 return ret0, ret1 2164 } 2165 2166 // CreateCustomerGatewayWithContext indicates an expected call of CreateCustomerGatewayWithContext 2167 func (mr *MockEC2APIMockRecorder) CreateCustomerGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2168 mr.mock.ctrl.T.Helper() 2169 varargs := append([]interface{}{arg0, arg1}, arg2...) 2170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGatewayWithContext), varargs...) 2171 } 2172 2173 // CreateCustomerGatewayRequest mocks base method 2174 func (m *MockEC2API) CreateCustomerGatewayRequest(arg0 *ec2.CreateCustomerGatewayInput) (*request.Request, *ec2.CreateCustomerGatewayOutput) { 2175 m.ctrl.T.Helper() 2176 ret := m.ctrl.Call(m, "CreateCustomerGatewayRequest", arg0) 2177 ret0, _ := ret[0].(*request.Request) 2178 ret1, _ := ret[1].(*ec2.CreateCustomerGatewayOutput) 2179 return ret0, ret1 2180 } 2181 2182 // CreateCustomerGatewayRequest indicates an expected call of CreateCustomerGatewayRequest 2183 func (mr *MockEC2APIMockRecorder) CreateCustomerGatewayRequest(arg0 interface{}) *gomock.Call { 2184 mr.mock.ctrl.T.Helper() 2185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateCustomerGatewayRequest), arg0) 2186 } 2187 2188 // CreateDefaultSubnet mocks base method 2189 func (m *MockEC2API) CreateDefaultSubnet(arg0 *ec2.CreateDefaultSubnetInput) (*ec2.CreateDefaultSubnetOutput, error) { 2190 m.ctrl.T.Helper() 2191 ret := m.ctrl.Call(m, "CreateDefaultSubnet", arg0) 2192 ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput) 2193 ret1, _ := ret[1].(error) 2194 return ret0, ret1 2195 } 2196 2197 // CreateDefaultSubnet indicates an expected call of CreateDefaultSubnet 2198 func (mr *MockEC2APIMockRecorder) CreateDefaultSubnet(arg0 interface{}) *gomock.Call { 2199 mr.mock.ctrl.T.Helper() 2200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnet), arg0) 2201 } 2202 2203 // CreateDefaultSubnetWithContext mocks base method 2204 func (m *MockEC2API) CreateDefaultSubnetWithContext(arg0 aws.Context, arg1 *ec2.CreateDefaultSubnetInput, arg2 ...request.Option) (*ec2.CreateDefaultSubnetOutput, error) { 2205 m.ctrl.T.Helper() 2206 varargs := []interface{}{arg0, arg1} 2207 for _, a := range arg2 { 2208 varargs = append(varargs, a) 2209 } 2210 ret := m.ctrl.Call(m, "CreateDefaultSubnetWithContext", varargs...) 2211 ret0, _ := ret[0].(*ec2.CreateDefaultSubnetOutput) 2212 ret1, _ := ret[1].(error) 2213 return ret0, ret1 2214 } 2215 2216 // CreateDefaultSubnetWithContext indicates an expected call of CreateDefaultSubnetWithContext 2217 func (mr *MockEC2APIMockRecorder) CreateDefaultSubnetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2218 mr.mock.ctrl.T.Helper() 2219 varargs := append([]interface{}{arg0, arg1}, arg2...) 2220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnetWithContext), varargs...) 2221 } 2222 2223 // CreateDefaultSubnetRequest mocks base method 2224 func (m *MockEC2API) CreateDefaultSubnetRequest(arg0 *ec2.CreateDefaultSubnetInput) (*request.Request, *ec2.CreateDefaultSubnetOutput) { 2225 m.ctrl.T.Helper() 2226 ret := m.ctrl.Call(m, "CreateDefaultSubnetRequest", arg0) 2227 ret0, _ := ret[0].(*request.Request) 2228 ret1, _ := ret[1].(*ec2.CreateDefaultSubnetOutput) 2229 return ret0, ret1 2230 } 2231 2232 // CreateDefaultSubnetRequest indicates an expected call of CreateDefaultSubnetRequest 2233 func (mr *MockEC2APIMockRecorder) CreateDefaultSubnetRequest(arg0 interface{}) *gomock.Call { 2234 mr.mock.ctrl.T.Helper() 2235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultSubnetRequest), arg0) 2236 } 2237 2238 // CreateDefaultVpc mocks base method 2239 func (m *MockEC2API) CreateDefaultVpc(arg0 *ec2.CreateDefaultVpcInput) (*ec2.CreateDefaultVpcOutput, error) { 2240 m.ctrl.T.Helper() 2241 ret := m.ctrl.Call(m, "CreateDefaultVpc", arg0) 2242 ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput) 2243 ret1, _ := ret[1].(error) 2244 return ret0, ret1 2245 } 2246 2247 // CreateDefaultVpc indicates an expected call of CreateDefaultVpc 2248 func (mr *MockEC2APIMockRecorder) CreateDefaultVpc(arg0 interface{}) *gomock.Call { 2249 mr.mock.ctrl.T.Helper() 2250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpc", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpc), arg0) 2251 } 2252 2253 // CreateDefaultVpcWithContext mocks base method 2254 func (m *MockEC2API) CreateDefaultVpcWithContext(arg0 aws.Context, arg1 *ec2.CreateDefaultVpcInput, arg2 ...request.Option) (*ec2.CreateDefaultVpcOutput, error) { 2255 m.ctrl.T.Helper() 2256 varargs := []interface{}{arg0, arg1} 2257 for _, a := range arg2 { 2258 varargs = append(varargs, a) 2259 } 2260 ret := m.ctrl.Call(m, "CreateDefaultVpcWithContext", varargs...) 2261 ret0, _ := ret[0].(*ec2.CreateDefaultVpcOutput) 2262 ret1, _ := ret[1].(error) 2263 return ret0, ret1 2264 } 2265 2266 // CreateDefaultVpcWithContext indicates an expected call of CreateDefaultVpcWithContext 2267 func (mr *MockEC2APIMockRecorder) CreateDefaultVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2268 mr.mock.ctrl.T.Helper() 2269 varargs := append([]interface{}{arg0, arg1}, arg2...) 2270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpcWithContext), varargs...) 2271 } 2272 2273 // CreateDefaultVpcRequest mocks base method 2274 func (m *MockEC2API) CreateDefaultVpcRequest(arg0 *ec2.CreateDefaultVpcInput) (*request.Request, *ec2.CreateDefaultVpcOutput) { 2275 m.ctrl.T.Helper() 2276 ret := m.ctrl.Call(m, "CreateDefaultVpcRequest", arg0) 2277 ret0, _ := ret[0].(*request.Request) 2278 ret1, _ := ret[1].(*ec2.CreateDefaultVpcOutput) 2279 return ret0, ret1 2280 } 2281 2282 // CreateDefaultVpcRequest indicates an expected call of CreateDefaultVpcRequest 2283 func (mr *MockEC2APIMockRecorder) CreateDefaultVpcRequest(arg0 interface{}) *gomock.Call { 2284 mr.mock.ctrl.T.Helper() 2285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDefaultVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDefaultVpcRequest), arg0) 2286 } 2287 2288 // CreateDhcpOptions mocks base method 2289 func (m *MockEC2API) CreateDhcpOptions(arg0 *ec2.CreateDhcpOptionsInput) (*ec2.CreateDhcpOptionsOutput, error) { 2290 m.ctrl.T.Helper() 2291 ret := m.ctrl.Call(m, "CreateDhcpOptions", arg0) 2292 ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput) 2293 ret1, _ := ret[1].(error) 2294 return ret0, ret1 2295 } 2296 2297 // CreateDhcpOptions indicates an expected call of CreateDhcpOptions 2298 func (mr *MockEC2APIMockRecorder) CreateDhcpOptions(arg0 interface{}) *gomock.Call { 2299 mr.mock.ctrl.T.Helper() 2300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptions), arg0) 2301 } 2302 2303 // CreateDhcpOptionsWithContext mocks base method 2304 func (m *MockEC2API) CreateDhcpOptionsWithContext(arg0 aws.Context, arg1 *ec2.CreateDhcpOptionsInput, arg2 ...request.Option) (*ec2.CreateDhcpOptionsOutput, error) { 2305 m.ctrl.T.Helper() 2306 varargs := []interface{}{arg0, arg1} 2307 for _, a := range arg2 { 2308 varargs = append(varargs, a) 2309 } 2310 ret := m.ctrl.Call(m, "CreateDhcpOptionsWithContext", varargs...) 2311 ret0, _ := ret[0].(*ec2.CreateDhcpOptionsOutput) 2312 ret1, _ := ret[1].(error) 2313 return ret0, ret1 2314 } 2315 2316 // CreateDhcpOptionsWithContext indicates an expected call of CreateDhcpOptionsWithContext 2317 func (mr *MockEC2APIMockRecorder) CreateDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2318 mr.mock.ctrl.T.Helper() 2319 varargs := append([]interface{}{arg0, arg1}, arg2...) 2320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptionsWithContext), varargs...) 2321 } 2322 2323 // CreateDhcpOptionsRequest mocks base method 2324 func (m *MockEC2API) CreateDhcpOptionsRequest(arg0 *ec2.CreateDhcpOptionsInput) (*request.Request, *ec2.CreateDhcpOptionsOutput) { 2325 m.ctrl.T.Helper() 2326 ret := m.ctrl.Call(m, "CreateDhcpOptionsRequest", arg0) 2327 ret0, _ := ret[0].(*request.Request) 2328 ret1, _ := ret[1].(*ec2.CreateDhcpOptionsOutput) 2329 return ret0, ret1 2330 } 2331 2332 // CreateDhcpOptionsRequest indicates an expected call of CreateDhcpOptionsRequest 2333 func (mr *MockEC2APIMockRecorder) CreateDhcpOptionsRequest(arg0 interface{}) *gomock.Call { 2334 mr.mock.ctrl.T.Helper() 2335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateDhcpOptionsRequest), arg0) 2336 } 2337 2338 // CreateEgressOnlyInternetGateway mocks base method 2339 func (m *MockEC2API) CreateEgressOnlyInternetGateway(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) { 2340 m.ctrl.T.Helper() 2341 ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGateway", arg0) 2342 ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput) 2343 ret1, _ := ret[1].(error) 2344 return ret0, ret1 2345 } 2346 2347 // CreateEgressOnlyInternetGateway indicates an expected call of CreateEgressOnlyInternetGateway 2348 func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call { 2349 mr.mock.ctrl.T.Helper() 2350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGateway), arg0) 2351 } 2352 2353 // CreateEgressOnlyInternetGatewayWithContext mocks base method 2354 func (m *MockEC2API) CreateEgressOnlyInternetGatewayWithContext(arg0 aws.Context, arg1 *ec2.CreateEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateEgressOnlyInternetGatewayOutput, error) { 2355 m.ctrl.T.Helper() 2356 varargs := []interface{}{arg0, arg1} 2357 for _, a := range arg2 { 2358 varargs = append(varargs, a) 2359 } 2360 ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayWithContext", varargs...) 2361 ret0, _ := ret[0].(*ec2.CreateEgressOnlyInternetGatewayOutput) 2362 ret1, _ := ret[1].(error) 2363 return ret0, ret1 2364 } 2365 2366 // CreateEgressOnlyInternetGatewayWithContext indicates an expected call of CreateEgressOnlyInternetGatewayWithContext 2367 func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2368 mr.mock.ctrl.T.Helper() 2369 varargs := append([]interface{}{arg0, arg1}, arg2...) 2370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayWithContext), varargs...) 2371 } 2372 2373 // CreateEgressOnlyInternetGatewayRequest mocks base method 2374 func (m *MockEC2API) CreateEgressOnlyInternetGatewayRequest(arg0 *ec2.CreateEgressOnlyInternetGatewayInput) (*request.Request, *ec2.CreateEgressOnlyInternetGatewayOutput) { 2375 m.ctrl.T.Helper() 2376 ret := m.ctrl.Call(m, "CreateEgressOnlyInternetGatewayRequest", arg0) 2377 ret0, _ := ret[0].(*request.Request) 2378 ret1, _ := ret[1].(*ec2.CreateEgressOnlyInternetGatewayOutput) 2379 return ret0, ret1 2380 } 2381 2382 // CreateEgressOnlyInternetGatewayRequest indicates an expected call of CreateEgressOnlyInternetGatewayRequest 2383 func (mr *MockEC2APIMockRecorder) CreateEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call { 2384 mr.mock.ctrl.T.Helper() 2385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateEgressOnlyInternetGatewayRequest), arg0) 2386 } 2387 2388 // CreateFleet mocks base method 2389 func (m *MockEC2API) CreateFleet(arg0 *ec2.CreateFleetInput) (*ec2.CreateFleetOutput, error) { 2390 m.ctrl.T.Helper() 2391 ret := m.ctrl.Call(m, "CreateFleet", arg0) 2392 ret0, _ := ret[0].(*ec2.CreateFleetOutput) 2393 ret1, _ := ret[1].(error) 2394 return ret0, ret1 2395 } 2396 2397 // CreateFleet indicates an expected call of CreateFleet 2398 func (mr *MockEC2APIMockRecorder) CreateFleet(arg0 interface{}) *gomock.Call { 2399 mr.mock.ctrl.T.Helper() 2400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleet", reflect.TypeOf((*MockEC2API)(nil).CreateFleet), arg0) 2401 } 2402 2403 // CreateFleetWithContext mocks base method 2404 func (m *MockEC2API) CreateFleetWithContext(arg0 aws.Context, arg1 *ec2.CreateFleetInput, arg2 ...request.Option) (*ec2.CreateFleetOutput, error) { 2405 m.ctrl.T.Helper() 2406 varargs := []interface{}{arg0, arg1} 2407 for _, a := range arg2 { 2408 varargs = append(varargs, a) 2409 } 2410 ret := m.ctrl.Call(m, "CreateFleetWithContext", varargs...) 2411 ret0, _ := ret[0].(*ec2.CreateFleetOutput) 2412 ret1, _ := ret[1].(error) 2413 return ret0, ret1 2414 } 2415 2416 // CreateFleetWithContext indicates an expected call of CreateFleetWithContext 2417 func (mr *MockEC2APIMockRecorder) CreateFleetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2418 mr.mock.ctrl.T.Helper() 2419 varargs := append([]interface{}{arg0, arg1}, arg2...) 2420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFleetWithContext), varargs...) 2421 } 2422 2423 // CreateFleetRequest mocks base method 2424 func (m *MockEC2API) CreateFleetRequest(arg0 *ec2.CreateFleetInput) (*request.Request, *ec2.CreateFleetOutput) { 2425 m.ctrl.T.Helper() 2426 ret := m.ctrl.Call(m, "CreateFleetRequest", arg0) 2427 ret0, _ := ret[0].(*request.Request) 2428 ret1, _ := ret[1].(*ec2.CreateFleetOutput) 2429 return ret0, ret1 2430 } 2431 2432 // CreateFleetRequest indicates an expected call of CreateFleetRequest 2433 func (mr *MockEC2APIMockRecorder) CreateFleetRequest(arg0 interface{}) *gomock.Call { 2434 mr.mock.ctrl.T.Helper() 2435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFleetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFleetRequest), arg0) 2436 } 2437 2438 // CreateFlowLogs mocks base method 2439 func (m *MockEC2API) CreateFlowLogs(arg0 *ec2.CreateFlowLogsInput) (*ec2.CreateFlowLogsOutput, error) { 2440 m.ctrl.T.Helper() 2441 ret := m.ctrl.Call(m, "CreateFlowLogs", arg0) 2442 ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput) 2443 ret1, _ := ret[1].(error) 2444 return ret0, ret1 2445 } 2446 2447 // CreateFlowLogs indicates an expected call of CreateFlowLogs 2448 func (mr *MockEC2APIMockRecorder) CreateFlowLogs(arg0 interface{}) *gomock.Call { 2449 mr.mock.ctrl.T.Helper() 2450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogs", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogs), arg0) 2451 } 2452 2453 // CreateFlowLogsWithContext mocks base method 2454 func (m *MockEC2API) CreateFlowLogsWithContext(arg0 aws.Context, arg1 *ec2.CreateFlowLogsInput, arg2 ...request.Option) (*ec2.CreateFlowLogsOutput, error) { 2455 m.ctrl.T.Helper() 2456 varargs := []interface{}{arg0, arg1} 2457 for _, a := range arg2 { 2458 varargs = append(varargs, a) 2459 } 2460 ret := m.ctrl.Call(m, "CreateFlowLogsWithContext", varargs...) 2461 ret0, _ := ret[0].(*ec2.CreateFlowLogsOutput) 2462 ret1, _ := ret[1].(error) 2463 return ret0, ret1 2464 } 2465 2466 // CreateFlowLogsWithContext indicates an expected call of CreateFlowLogsWithContext 2467 func (mr *MockEC2APIMockRecorder) CreateFlowLogsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2468 mr.mock.ctrl.T.Helper() 2469 varargs := append([]interface{}{arg0, arg1}, arg2...) 2470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogsWithContext), varargs...) 2471 } 2472 2473 // CreateFlowLogsRequest mocks base method 2474 func (m *MockEC2API) CreateFlowLogsRequest(arg0 *ec2.CreateFlowLogsInput) (*request.Request, *ec2.CreateFlowLogsOutput) { 2475 m.ctrl.T.Helper() 2476 ret := m.ctrl.Call(m, "CreateFlowLogsRequest", arg0) 2477 ret0, _ := ret[0].(*request.Request) 2478 ret1, _ := ret[1].(*ec2.CreateFlowLogsOutput) 2479 return ret0, ret1 2480 } 2481 2482 // CreateFlowLogsRequest indicates an expected call of CreateFlowLogsRequest 2483 func (mr *MockEC2APIMockRecorder) CreateFlowLogsRequest(arg0 interface{}) *gomock.Call { 2484 mr.mock.ctrl.T.Helper() 2485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFlowLogsRequest), arg0) 2486 } 2487 2488 // CreateFpgaImage mocks base method 2489 func (m *MockEC2API) CreateFpgaImage(arg0 *ec2.CreateFpgaImageInput) (*ec2.CreateFpgaImageOutput, error) { 2490 m.ctrl.T.Helper() 2491 ret := m.ctrl.Call(m, "CreateFpgaImage", arg0) 2492 ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput) 2493 ret1, _ := ret[1].(error) 2494 return ret0, ret1 2495 } 2496 2497 // CreateFpgaImage indicates an expected call of CreateFpgaImage 2498 func (mr *MockEC2APIMockRecorder) CreateFpgaImage(arg0 interface{}) *gomock.Call { 2499 mr.mock.ctrl.T.Helper() 2500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImage", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImage), arg0) 2501 } 2502 2503 // CreateFpgaImageWithContext mocks base method 2504 func (m *MockEC2API) CreateFpgaImageWithContext(arg0 aws.Context, arg1 *ec2.CreateFpgaImageInput, arg2 ...request.Option) (*ec2.CreateFpgaImageOutput, error) { 2505 m.ctrl.T.Helper() 2506 varargs := []interface{}{arg0, arg1} 2507 for _, a := range arg2 { 2508 varargs = append(varargs, a) 2509 } 2510 ret := m.ctrl.Call(m, "CreateFpgaImageWithContext", varargs...) 2511 ret0, _ := ret[0].(*ec2.CreateFpgaImageOutput) 2512 ret1, _ := ret[1].(error) 2513 return ret0, ret1 2514 } 2515 2516 // CreateFpgaImageWithContext indicates an expected call of CreateFpgaImageWithContext 2517 func (mr *MockEC2APIMockRecorder) CreateFpgaImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2518 mr.mock.ctrl.T.Helper() 2519 varargs := append([]interface{}{arg0, arg1}, arg2...) 2520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImageWithContext), varargs...) 2521 } 2522 2523 // CreateFpgaImageRequest mocks base method 2524 func (m *MockEC2API) CreateFpgaImageRequest(arg0 *ec2.CreateFpgaImageInput) (*request.Request, *ec2.CreateFpgaImageOutput) { 2525 m.ctrl.T.Helper() 2526 ret := m.ctrl.Call(m, "CreateFpgaImageRequest", arg0) 2527 ret0, _ := ret[0].(*request.Request) 2528 ret1, _ := ret[1].(*ec2.CreateFpgaImageOutput) 2529 return ret0, ret1 2530 } 2531 2532 // CreateFpgaImageRequest indicates an expected call of CreateFpgaImageRequest 2533 func (mr *MockEC2APIMockRecorder) CreateFpgaImageRequest(arg0 interface{}) *gomock.Call { 2534 mr.mock.ctrl.T.Helper() 2535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateFpgaImageRequest), arg0) 2536 } 2537 2538 // CreateImage mocks base method 2539 func (m *MockEC2API) CreateImage(arg0 *ec2.CreateImageInput) (*ec2.CreateImageOutput, error) { 2540 m.ctrl.T.Helper() 2541 ret := m.ctrl.Call(m, "CreateImage", arg0) 2542 ret0, _ := ret[0].(*ec2.CreateImageOutput) 2543 ret1, _ := ret[1].(error) 2544 return ret0, ret1 2545 } 2546 2547 // CreateImage indicates an expected call of CreateImage 2548 func (mr *MockEC2APIMockRecorder) CreateImage(arg0 interface{}) *gomock.Call { 2549 mr.mock.ctrl.T.Helper() 2550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImage", reflect.TypeOf((*MockEC2API)(nil).CreateImage), arg0) 2551 } 2552 2553 // CreateImageWithContext mocks base method 2554 func (m *MockEC2API) CreateImageWithContext(arg0 aws.Context, arg1 *ec2.CreateImageInput, arg2 ...request.Option) (*ec2.CreateImageOutput, error) { 2555 m.ctrl.T.Helper() 2556 varargs := []interface{}{arg0, arg1} 2557 for _, a := range arg2 { 2558 varargs = append(varargs, a) 2559 } 2560 ret := m.ctrl.Call(m, "CreateImageWithContext", varargs...) 2561 ret0, _ := ret[0].(*ec2.CreateImageOutput) 2562 ret1, _ := ret[1].(error) 2563 return ret0, ret1 2564 } 2565 2566 // CreateImageWithContext indicates an expected call of CreateImageWithContext 2567 func (mr *MockEC2APIMockRecorder) CreateImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2568 mr.mock.ctrl.T.Helper() 2569 varargs := append([]interface{}{arg0, arg1}, arg2...) 2570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateImageWithContext), varargs...) 2571 } 2572 2573 // CreateImageRequest mocks base method 2574 func (m *MockEC2API) CreateImageRequest(arg0 *ec2.CreateImageInput) (*request.Request, *ec2.CreateImageOutput) { 2575 m.ctrl.T.Helper() 2576 ret := m.ctrl.Call(m, "CreateImageRequest", arg0) 2577 ret0, _ := ret[0].(*request.Request) 2578 ret1, _ := ret[1].(*ec2.CreateImageOutput) 2579 return ret0, ret1 2580 } 2581 2582 // CreateImageRequest indicates an expected call of CreateImageRequest 2583 func (mr *MockEC2APIMockRecorder) CreateImageRequest(arg0 interface{}) *gomock.Call { 2584 mr.mock.ctrl.T.Helper() 2585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateImageRequest", reflect.TypeOf((*MockEC2API)(nil).CreateImageRequest), arg0) 2586 } 2587 2588 // CreateInstanceExportTask mocks base method 2589 func (m *MockEC2API) CreateInstanceExportTask(arg0 *ec2.CreateInstanceExportTaskInput) (*ec2.CreateInstanceExportTaskOutput, error) { 2590 m.ctrl.T.Helper() 2591 ret := m.ctrl.Call(m, "CreateInstanceExportTask", arg0) 2592 ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput) 2593 ret1, _ := ret[1].(error) 2594 return ret0, ret1 2595 } 2596 2597 // CreateInstanceExportTask indicates an expected call of CreateInstanceExportTask 2598 func (mr *MockEC2APIMockRecorder) CreateInstanceExportTask(arg0 interface{}) *gomock.Call { 2599 mr.mock.ctrl.T.Helper() 2600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTask", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTask), arg0) 2601 } 2602 2603 // CreateInstanceExportTaskWithContext mocks base method 2604 func (m *MockEC2API) CreateInstanceExportTaskWithContext(arg0 aws.Context, arg1 *ec2.CreateInstanceExportTaskInput, arg2 ...request.Option) (*ec2.CreateInstanceExportTaskOutput, error) { 2605 m.ctrl.T.Helper() 2606 varargs := []interface{}{arg0, arg1} 2607 for _, a := range arg2 { 2608 varargs = append(varargs, a) 2609 } 2610 ret := m.ctrl.Call(m, "CreateInstanceExportTaskWithContext", varargs...) 2611 ret0, _ := ret[0].(*ec2.CreateInstanceExportTaskOutput) 2612 ret1, _ := ret[1].(error) 2613 return ret0, ret1 2614 } 2615 2616 // CreateInstanceExportTaskWithContext indicates an expected call of CreateInstanceExportTaskWithContext 2617 func (mr *MockEC2APIMockRecorder) CreateInstanceExportTaskWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2618 mr.mock.ctrl.T.Helper() 2619 varargs := append([]interface{}{arg0, arg1}, arg2...) 2620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTaskWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTaskWithContext), varargs...) 2621 } 2622 2623 // CreateInstanceExportTaskRequest mocks base method 2624 func (m *MockEC2API) CreateInstanceExportTaskRequest(arg0 *ec2.CreateInstanceExportTaskInput) (*request.Request, *ec2.CreateInstanceExportTaskOutput) { 2625 m.ctrl.T.Helper() 2626 ret := m.ctrl.Call(m, "CreateInstanceExportTaskRequest", arg0) 2627 ret0, _ := ret[0].(*request.Request) 2628 ret1, _ := ret[1].(*ec2.CreateInstanceExportTaskOutput) 2629 return ret0, ret1 2630 } 2631 2632 // CreateInstanceExportTaskRequest indicates an expected call of CreateInstanceExportTaskRequest 2633 func (mr *MockEC2APIMockRecorder) CreateInstanceExportTaskRequest(arg0 interface{}) *gomock.Call { 2634 mr.mock.ctrl.T.Helper() 2635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInstanceExportTaskRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInstanceExportTaskRequest), arg0) 2636 } 2637 2638 // CreateInternetGateway mocks base method 2639 func (m *MockEC2API) CreateInternetGateway(arg0 *ec2.CreateInternetGatewayInput) (*ec2.CreateInternetGatewayOutput, error) { 2640 m.ctrl.T.Helper() 2641 ret := m.ctrl.Call(m, "CreateInternetGateway", arg0) 2642 ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput) 2643 ret1, _ := ret[1].(error) 2644 return ret0, ret1 2645 } 2646 2647 // CreateInternetGateway indicates an expected call of CreateInternetGateway 2648 func (mr *MockEC2APIMockRecorder) CreateInternetGateway(arg0 interface{}) *gomock.Call { 2649 mr.mock.ctrl.T.Helper() 2650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGateway", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGateway), arg0) 2651 } 2652 2653 // CreateInternetGatewayWithContext mocks base method 2654 func (m *MockEC2API) CreateInternetGatewayWithContext(arg0 aws.Context, arg1 *ec2.CreateInternetGatewayInput, arg2 ...request.Option) (*ec2.CreateInternetGatewayOutput, error) { 2655 m.ctrl.T.Helper() 2656 varargs := []interface{}{arg0, arg1} 2657 for _, a := range arg2 { 2658 varargs = append(varargs, a) 2659 } 2660 ret := m.ctrl.Call(m, "CreateInternetGatewayWithContext", varargs...) 2661 ret0, _ := ret[0].(*ec2.CreateInternetGatewayOutput) 2662 ret1, _ := ret[1].(error) 2663 return ret0, ret1 2664 } 2665 2666 // CreateInternetGatewayWithContext indicates an expected call of CreateInternetGatewayWithContext 2667 func (mr *MockEC2APIMockRecorder) CreateInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2668 mr.mock.ctrl.T.Helper() 2669 varargs := append([]interface{}{arg0, arg1}, arg2...) 2670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGatewayWithContext), varargs...) 2671 } 2672 2673 // CreateInternetGatewayRequest mocks base method 2674 func (m *MockEC2API) CreateInternetGatewayRequest(arg0 *ec2.CreateInternetGatewayInput) (*request.Request, *ec2.CreateInternetGatewayOutput) { 2675 m.ctrl.T.Helper() 2676 ret := m.ctrl.Call(m, "CreateInternetGatewayRequest", arg0) 2677 ret0, _ := ret[0].(*request.Request) 2678 ret1, _ := ret[1].(*ec2.CreateInternetGatewayOutput) 2679 return ret0, ret1 2680 } 2681 2682 // CreateInternetGatewayRequest indicates an expected call of CreateInternetGatewayRequest 2683 func (mr *MockEC2APIMockRecorder) CreateInternetGatewayRequest(arg0 interface{}) *gomock.Call { 2684 mr.mock.ctrl.T.Helper() 2685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateInternetGatewayRequest), arg0) 2686 } 2687 2688 // CreateKeyPair mocks base method 2689 func (m *MockEC2API) CreateKeyPair(arg0 *ec2.CreateKeyPairInput) (*ec2.CreateKeyPairOutput, error) { 2690 m.ctrl.T.Helper() 2691 ret := m.ctrl.Call(m, "CreateKeyPair", arg0) 2692 ret0, _ := ret[0].(*ec2.CreateKeyPairOutput) 2693 ret1, _ := ret[1].(error) 2694 return ret0, ret1 2695 } 2696 2697 // CreateKeyPair indicates an expected call of CreateKeyPair 2698 func (mr *MockEC2APIMockRecorder) CreateKeyPair(arg0 interface{}) *gomock.Call { 2699 mr.mock.ctrl.T.Helper() 2700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPair", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPair), arg0) 2701 } 2702 2703 // CreateKeyPairWithContext mocks base method 2704 func (m *MockEC2API) CreateKeyPairWithContext(arg0 aws.Context, arg1 *ec2.CreateKeyPairInput, arg2 ...request.Option) (*ec2.CreateKeyPairOutput, error) { 2705 m.ctrl.T.Helper() 2706 varargs := []interface{}{arg0, arg1} 2707 for _, a := range arg2 { 2708 varargs = append(varargs, a) 2709 } 2710 ret := m.ctrl.Call(m, "CreateKeyPairWithContext", varargs...) 2711 ret0, _ := ret[0].(*ec2.CreateKeyPairOutput) 2712 ret1, _ := ret[1].(error) 2713 return ret0, ret1 2714 } 2715 2716 // CreateKeyPairWithContext indicates an expected call of CreateKeyPairWithContext 2717 func (mr *MockEC2APIMockRecorder) CreateKeyPairWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2718 mr.mock.ctrl.T.Helper() 2719 varargs := append([]interface{}{arg0, arg1}, arg2...) 2720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPairWithContext), varargs...) 2721 } 2722 2723 // CreateKeyPairRequest mocks base method 2724 func (m *MockEC2API) CreateKeyPairRequest(arg0 *ec2.CreateKeyPairInput) (*request.Request, *ec2.CreateKeyPairOutput) { 2725 m.ctrl.T.Helper() 2726 ret := m.ctrl.Call(m, "CreateKeyPairRequest", arg0) 2727 ret0, _ := ret[0].(*request.Request) 2728 ret1, _ := ret[1].(*ec2.CreateKeyPairOutput) 2729 return ret0, ret1 2730 } 2731 2732 // CreateKeyPairRequest indicates an expected call of CreateKeyPairRequest 2733 func (mr *MockEC2APIMockRecorder) CreateKeyPairRequest(arg0 interface{}) *gomock.Call { 2734 mr.mock.ctrl.T.Helper() 2735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).CreateKeyPairRequest), arg0) 2736 } 2737 2738 // CreateLaunchTemplate mocks base method 2739 func (m *MockEC2API) CreateLaunchTemplate(arg0 *ec2.CreateLaunchTemplateInput) (*ec2.CreateLaunchTemplateOutput, error) { 2740 m.ctrl.T.Helper() 2741 ret := m.ctrl.Call(m, "CreateLaunchTemplate", arg0) 2742 ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput) 2743 ret1, _ := ret[1].(error) 2744 return ret0, ret1 2745 } 2746 2747 // CreateLaunchTemplate indicates an expected call of CreateLaunchTemplate 2748 func (mr *MockEC2APIMockRecorder) CreateLaunchTemplate(arg0 interface{}) *gomock.Call { 2749 mr.mock.ctrl.T.Helper() 2750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplate), arg0) 2751 } 2752 2753 // CreateLaunchTemplateWithContext mocks base method 2754 func (m *MockEC2API) CreateLaunchTemplateWithContext(arg0 aws.Context, arg1 *ec2.CreateLaunchTemplateInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateOutput, error) { 2755 m.ctrl.T.Helper() 2756 varargs := []interface{}{arg0, arg1} 2757 for _, a := range arg2 { 2758 varargs = append(varargs, a) 2759 } 2760 ret := m.ctrl.Call(m, "CreateLaunchTemplateWithContext", varargs...) 2761 ret0, _ := ret[0].(*ec2.CreateLaunchTemplateOutput) 2762 ret1, _ := ret[1].(error) 2763 return ret0, ret1 2764 } 2765 2766 // CreateLaunchTemplateWithContext indicates an expected call of CreateLaunchTemplateWithContext 2767 func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2768 mr.mock.ctrl.T.Helper() 2769 varargs := append([]interface{}{arg0, arg1}, arg2...) 2770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateWithContext), varargs...) 2771 } 2772 2773 // CreateLaunchTemplateRequest mocks base method 2774 func (m *MockEC2API) CreateLaunchTemplateRequest(arg0 *ec2.CreateLaunchTemplateInput) (*request.Request, *ec2.CreateLaunchTemplateOutput) { 2775 m.ctrl.T.Helper() 2776 ret := m.ctrl.Call(m, "CreateLaunchTemplateRequest", arg0) 2777 ret0, _ := ret[0].(*request.Request) 2778 ret1, _ := ret[1].(*ec2.CreateLaunchTemplateOutput) 2779 return ret0, ret1 2780 } 2781 2782 // CreateLaunchTemplateRequest indicates an expected call of CreateLaunchTemplateRequest 2783 func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateRequest(arg0 interface{}) *gomock.Call { 2784 mr.mock.ctrl.T.Helper() 2785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateRequest), arg0) 2786 } 2787 2788 // CreateLaunchTemplateVersion mocks base method 2789 func (m *MockEC2API) CreateLaunchTemplateVersion(arg0 *ec2.CreateLaunchTemplateVersionInput) (*ec2.CreateLaunchTemplateVersionOutput, error) { 2790 m.ctrl.T.Helper() 2791 ret := m.ctrl.Call(m, "CreateLaunchTemplateVersion", arg0) 2792 ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput) 2793 ret1, _ := ret[1].(error) 2794 return ret0, ret1 2795 } 2796 2797 // CreateLaunchTemplateVersion indicates an expected call of CreateLaunchTemplateVersion 2798 func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersion(arg0 interface{}) *gomock.Call { 2799 mr.mock.ctrl.T.Helper() 2800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersion", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersion), arg0) 2801 } 2802 2803 // CreateLaunchTemplateVersionWithContext mocks base method 2804 func (m *MockEC2API) CreateLaunchTemplateVersionWithContext(arg0 aws.Context, arg1 *ec2.CreateLaunchTemplateVersionInput, arg2 ...request.Option) (*ec2.CreateLaunchTemplateVersionOutput, error) { 2805 m.ctrl.T.Helper() 2806 varargs := []interface{}{arg0, arg1} 2807 for _, a := range arg2 { 2808 varargs = append(varargs, a) 2809 } 2810 ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionWithContext", varargs...) 2811 ret0, _ := ret[0].(*ec2.CreateLaunchTemplateVersionOutput) 2812 ret1, _ := ret[1].(error) 2813 return ret0, ret1 2814 } 2815 2816 // CreateLaunchTemplateVersionWithContext indicates an expected call of CreateLaunchTemplateVersionWithContext 2817 func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2818 mr.mock.ctrl.T.Helper() 2819 varargs := append([]interface{}{arg0, arg1}, arg2...) 2820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersionWithContext), varargs...) 2821 } 2822 2823 // CreateLaunchTemplateVersionRequest mocks base method 2824 func (m *MockEC2API) CreateLaunchTemplateVersionRequest(arg0 *ec2.CreateLaunchTemplateVersionInput) (*request.Request, *ec2.CreateLaunchTemplateVersionOutput) { 2825 m.ctrl.T.Helper() 2826 ret := m.ctrl.Call(m, "CreateLaunchTemplateVersionRequest", arg0) 2827 ret0, _ := ret[0].(*request.Request) 2828 ret1, _ := ret[1].(*ec2.CreateLaunchTemplateVersionOutput) 2829 return ret0, ret1 2830 } 2831 2832 // CreateLaunchTemplateVersionRequest indicates an expected call of CreateLaunchTemplateVersionRequest 2833 func (mr *MockEC2APIMockRecorder) CreateLaunchTemplateVersionRequest(arg0 interface{}) *gomock.Call { 2834 mr.mock.ctrl.T.Helper() 2835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateLaunchTemplateVersionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateLaunchTemplateVersionRequest), arg0) 2836 } 2837 2838 // CreateNatGateway mocks base method 2839 func (m *MockEC2API) CreateNatGateway(arg0 *ec2.CreateNatGatewayInput) (*ec2.CreateNatGatewayOutput, error) { 2840 m.ctrl.T.Helper() 2841 ret := m.ctrl.Call(m, "CreateNatGateway", arg0) 2842 ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput) 2843 ret1, _ := ret[1].(error) 2844 return ret0, ret1 2845 } 2846 2847 // CreateNatGateway indicates an expected call of CreateNatGateway 2848 func (mr *MockEC2APIMockRecorder) CreateNatGateway(arg0 interface{}) *gomock.Call { 2849 mr.mock.ctrl.T.Helper() 2850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGateway", reflect.TypeOf((*MockEC2API)(nil).CreateNatGateway), arg0) 2851 } 2852 2853 // CreateNatGatewayWithContext mocks base method 2854 func (m *MockEC2API) CreateNatGatewayWithContext(arg0 aws.Context, arg1 *ec2.CreateNatGatewayInput, arg2 ...request.Option) (*ec2.CreateNatGatewayOutput, error) { 2855 m.ctrl.T.Helper() 2856 varargs := []interface{}{arg0, arg1} 2857 for _, a := range arg2 { 2858 varargs = append(varargs, a) 2859 } 2860 ret := m.ctrl.Call(m, "CreateNatGatewayWithContext", varargs...) 2861 ret0, _ := ret[0].(*ec2.CreateNatGatewayOutput) 2862 ret1, _ := ret[1].(error) 2863 return ret0, ret1 2864 } 2865 2866 // CreateNatGatewayWithContext indicates an expected call of CreateNatGatewayWithContext 2867 func (mr *MockEC2APIMockRecorder) CreateNatGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2868 mr.mock.ctrl.T.Helper() 2869 varargs := append([]interface{}{arg0, arg1}, arg2...) 2870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNatGatewayWithContext), varargs...) 2871 } 2872 2873 // CreateNatGatewayRequest mocks base method 2874 func (m *MockEC2API) CreateNatGatewayRequest(arg0 *ec2.CreateNatGatewayInput) (*request.Request, *ec2.CreateNatGatewayOutput) { 2875 m.ctrl.T.Helper() 2876 ret := m.ctrl.Call(m, "CreateNatGatewayRequest", arg0) 2877 ret0, _ := ret[0].(*request.Request) 2878 ret1, _ := ret[1].(*ec2.CreateNatGatewayOutput) 2879 return ret0, ret1 2880 } 2881 2882 // CreateNatGatewayRequest indicates an expected call of CreateNatGatewayRequest 2883 func (mr *MockEC2APIMockRecorder) CreateNatGatewayRequest(arg0 interface{}) *gomock.Call { 2884 mr.mock.ctrl.T.Helper() 2885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNatGatewayRequest), arg0) 2886 } 2887 2888 // CreateNetworkAcl mocks base method 2889 func (m *MockEC2API) CreateNetworkAcl(arg0 *ec2.CreateNetworkAclInput) (*ec2.CreateNetworkAclOutput, error) { 2890 m.ctrl.T.Helper() 2891 ret := m.ctrl.Call(m, "CreateNetworkAcl", arg0) 2892 ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput) 2893 ret1, _ := ret[1].(error) 2894 return ret0, ret1 2895 } 2896 2897 // CreateNetworkAcl indicates an expected call of CreateNetworkAcl 2898 func (mr *MockEC2APIMockRecorder) CreateNetworkAcl(arg0 interface{}) *gomock.Call { 2899 mr.mock.ctrl.T.Helper() 2900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAcl), arg0) 2901 } 2902 2903 // CreateNetworkAclWithContext mocks base method 2904 func (m *MockEC2API) CreateNetworkAclWithContext(arg0 aws.Context, arg1 *ec2.CreateNetworkAclInput, arg2 ...request.Option) (*ec2.CreateNetworkAclOutput, error) { 2905 m.ctrl.T.Helper() 2906 varargs := []interface{}{arg0, arg1} 2907 for _, a := range arg2 { 2908 varargs = append(varargs, a) 2909 } 2910 ret := m.ctrl.Call(m, "CreateNetworkAclWithContext", varargs...) 2911 ret0, _ := ret[0].(*ec2.CreateNetworkAclOutput) 2912 ret1, _ := ret[1].(error) 2913 return ret0, ret1 2914 } 2915 2916 // CreateNetworkAclWithContext indicates an expected call of CreateNetworkAclWithContext 2917 func (mr *MockEC2APIMockRecorder) CreateNetworkAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2918 mr.mock.ctrl.T.Helper() 2919 varargs := append([]interface{}{arg0, arg1}, arg2...) 2920 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclWithContext), varargs...) 2921 } 2922 2923 // CreateNetworkAclRequest mocks base method 2924 func (m *MockEC2API) CreateNetworkAclRequest(arg0 *ec2.CreateNetworkAclInput) (*request.Request, *ec2.CreateNetworkAclOutput) { 2925 m.ctrl.T.Helper() 2926 ret := m.ctrl.Call(m, "CreateNetworkAclRequest", arg0) 2927 ret0, _ := ret[0].(*request.Request) 2928 ret1, _ := ret[1].(*ec2.CreateNetworkAclOutput) 2929 return ret0, ret1 2930 } 2931 2932 // CreateNetworkAclRequest indicates an expected call of CreateNetworkAclRequest 2933 func (mr *MockEC2APIMockRecorder) CreateNetworkAclRequest(arg0 interface{}) *gomock.Call { 2934 mr.mock.ctrl.T.Helper() 2935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclRequest), arg0) 2936 } 2937 2938 // CreateNetworkAclEntry mocks base method 2939 func (m *MockEC2API) CreateNetworkAclEntry(arg0 *ec2.CreateNetworkAclEntryInput) (*ec2.CreateNetworkAclEntryOutput, error) { 2940 m.ctrl.T.Helper() 2941 ret := m.ctrl.Call(m, "CreateNetworkAclEntry", arg0) 2942 ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput) 2943 ret1, _ := ret[1].(error) 2944 return ret0, ret1 2945 } 2946 2947 // CreateNetworkAclEntry indicates an expected call of CreateNetworkAclEntry 2948 func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntry(arg0 interface{}) *gomock.Call { 2949 mr.mock.ctrl.T.Helper() 2950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntry), arg0) 2951 } 2952 2953 // CreateNetworkAclEntryWithContext mocks base method 2954 func (m *MockEC2API) CreateNetworkAclEntryWithContext(arg0 aws.Context, arg1 *ec2.CreateNetworkAclEntryInput, arg2 ...request.Option) (*ec2.CreateNetworkAclEntryOutput, error) { 2955 m.ctrl.T.Helper() 2956 varargs := []interface{}{arg0, arg1} 2957 for _, a := range arg2 { 2958 varargs = append(varargs, a) 2959 } 2960 ret := m.ctrl.Call(m, "CreateNetworkAclEntryWithContext", varargs...) 2961 ret0, _ := ret[0].(*ec2.CreateNetworkAclEntryOutput) 2962 ret1, _ := ret[1].(error) 2963 return ret0, ret1 2964 } 2965 2966 // CreateNetworkAclEntryWithContext indicates an expected call of CreateNetworkAclEntryWithContext 2967 func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 2968 mr.mock.ctrl.T.Helper() 2969 varargs := append([]interface{}{arg0, arg1}, arg2...) 2970 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntryWithContext), varargs...) 2971 } 2972 2973 // CreateNetworkAclEntryRequest mocks base method 2974 func (m *MockEC2API) CreateNetworkAclEntryRequest(arg0 *ec2.CreateNetworkAclEntryInput) (*request.Request, *ec2.CreateNetworkAclEntryOutput) { 2975 m.ctrl.T.Helper() 2976 ret := m.ctrl.Call(m, "CreateNetworkAclEntryRequest", arg0) 2977 ret0, _ := ret[0].(*request.Request) 2978 ret1, _ := ret[1].(*ec2.CreateNetworkAclEntryOutput) 2979 return ret0, ret1 2980 } 2981 2982 // CreateNetworkAclEntryRequest indicates an expected call of CreateNetworkAclEntryRequest 2983 func (mr *MockEC2APIMockRecorder) CreateNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { 2984 mr.mock.ctrl.T.Helper() 2985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkAclEntryRequest), arg0) 2986 } 2987 2988 // CreateNetworkInterface mocks base method 2989 func (m *MockEC2API) CreateNetworkInterface(arg0 *ec2.CreateNetworkInterfaceInput) (*ec2.CreateNetworkInterfaceOutput, error) { 2990 m.ctrl.T.Helper() 2991 ret := m.ctrl.Call(m, "CreateNetworkInterface", arg0) 2992 ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput) 2993 ret1, _ := ret[1].(error) 2994 return ret0, ret1 2995 } 2996 2997 // CreateNetworkInterface indicates an expected call of CreateNetworkInterface 2998 func (mr *MockEC2APIMockRecorder) CreateNetworkInterface(arg0 interface{}) *gomock.Call { 2999 mr.mock.ctrl.T.Helper() 3000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterface), arg0) 3001 } 3002 3003 // CreateNetworkInterfaceWithContext mocks base method 3004 func (m *MockEC2API) CreateNetworkInterfaceWithContext(arg0 aws.Context, arg1 *ec2.CreateNetworkInterfaceInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfaceOutput, error) { 3005 m.ctrl.T.Helper() 3006 varargs := []interface{}{arg0, arg1} 3007 for _, a := range arg2 { 3008 varargs = append(varargs, a) 3009 } 3010 ret := m.ctrl.Call(m, "CreateNetworkInterfaceWithContext", varargs...) 3011 ret0, _ := ret[0].(*ec2.CreateNetworkInterfaceOutput) 3012 ret1, _ := ret[1].(error) 3013 return ret0, ret1 3014 } 3015 3016 // CreateNetworkInterfaceWithContext indicates an expected call of CreateNetworkInterfaceWithContext 3017 func (mr *MockEC2APIMockRecorder) CreateNetworkInterfaceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3018 mr.mock.ctrl.T.Helper() 3019 varargs := append([]interface{}{arg0, arg1}, arg2...) 3020 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfaceWithContext), varargs...) 3021 } 3022 3023 // CreateNetworkInterfaceRequest mocks base method 3024 func (m *MockEC2API) CreateNetworkInterfaceRequest(arg0 *ec2.CreateNetworkInterfaceInput) (*request.Request, *ec2.CreateNetworkInterfaceOutput) { 3025 m.ctrl.T.Helper() 3026 ret := m.ctrl.Call(m, "CreateNetworkInterfaceRequest", arg0) 3027 ret0, _ := ret[0].(*request.Request) 3028 ret1, _ := ret[1].(*ec2.CreateNetworkInterfaceOutput) 3029 return ret0, ret1 3030 } 3031 3032 // CreateNetworkInterfaceRequest indicates an expected call of CreateNetworkInterfaceRequest 3033 func (mr *MockEC2APIMockRecorder) CreateNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { 3034 mr.mock.ctrl.T.Helper() 3035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfaceRequest), arg0) 3036 } 3037 3038 // CreateNetworkInterfacePermission mocks base method 3039 func (m *MockEC2API) CreateNetworkInterfacePermission(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*ec2.CreateNetworkInterfacePermissionOutput, error) { 3040 m.ctrl.T.Helper() 3041 ret := m.ctrl.Call(m, "CreateNetworkInterfacePermission", arg0) 3042 ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput) 3043 ret1, _ := ret[1].(error) 3044 return ret0, ret1 3045 } 3046 3047 // CreateNetworkInterfacePermission indicates an expected call of CreateNetworkInterfacePermission 3048 func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermission(arg0 interface{}) *gomock.Call { 3049 mr.mock.ctrl.T.Helper() 3050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermission), arg0) 3051 } 3052 3053 // CreateNetworkInterfacePermissionWithContext mocks base method 3054 func (m *MockEC2API) CreateNetworkInterfacePermissionWithContext(arg0 aws.Context, arg1 *ec2.CreateNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.CreateNetworkInterfacePermissionOutput, error) { 3055 m.ctrl.T.Helper() 3056 varargs := []interface{}{arg0, arg1} 3057 for _, a := range arg2 { 3058 varargs = append(varargs, a) 3059 } 3060 ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionWithContext", varargs...) 3061 ret0, _ := ret[0].(*ec2.CreateNetworkInterfacePermissionOutput) 3062 ret1, _ := ret[1].(error) 3063 return ret0, ret1 3064 } 3065 3066 // CreateNetworkInterfacePermissionWithContext indicates an expected call of CreateNetworkInterfacePermissionWithContext 3067 func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3068 mr.mock.ctrl.T.Helper() 3069 varargs := append([]interface{}{arg0, arg1}, arg2...) 3070 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermissionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermissionWithContext), varargs...) 3071 } 3072 3073 // CreateNetworkInterfacePermissionRequest mocks base method 3074 func (m *MockEC2API) CreateNetworkInterfacePermissionRequest(arg0 *ec2.CreateNetworkInterfacePermissionInput) (*request.Request, *ec2.CreateNetworkInterfacePermissionOutput) { 3075 m.ctrl.T.Helper() 3076 ret := m.ctrl.Call(m, "CreateNetworkInterfacePermissionRequest", arg0) 3077 ret0, _ := ret[0].(*request.Request) 3078 ret1, _ := ret[1].(*ec2.CreateNetworkInterfacePermissionOutput) 3079 return ret0, ret1 3080 } 3081 3082 // CreateNetworkInterfacePermissionRequest indicates an expected call of CreateNetworkInterfacePermissionRequest 3083 func (mr *MockEC2APIMockRecorder) CreateNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call { 3084 mr.mock.ctrl.T.Helper() 3085 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateNetworkInterfacePermissionRequest), arg0) 3086 } 3087 3088 // CreatePlacementGroup mocks base method 3089 func (m *MockEC2API) CreatePlacementGroup(arg0 *ec2.CreatePlacementGroupInput) (*ec2.CreatePlacementGroupOutput, error) { 3090 m.ctrl.T.Helper() 3091 ret := m.ctrl.Call(m, "CreatePlacementGroup", arg0) 3092 ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput) 3093 ret1, _ := ret[1].(error) 3094 return ret0, ret1 3095 } 3096 3097 // CreatePlacementGroup indicates an expected call of CreatePlacementGroup 3098 func (mr *MockEC2APIMockRecorder) CreatePlacementGroup(arg0 interface{}) *gomock.Call { 3099 mr.mock.ctrl.T.Helper() 3100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroup), arg0) 3101 } 3102 3103 // CreatePlacementGroupWithContext mocks base method 3104 func (m *MockEC2API) CreatePlacementGroupWithContext(arg0 aws.Context, arg1 *ec2.CreatePlacementGroupInput, arg2 ...request.Option) (*ec2.CreatePlacementGroupOutput, error) { 3105 m.ctrl.T.Helper() 3106 varargs := []interface{}{arg0, arg1} 3107 for _, a := range arg2 { 3108 varargs = append(varargs, a) 3109 } 3110 ret := m.ctrl.Call(m, "CreatePlacementGroupWithContext", varargs...) 3111 ret0, _ := ret[0].(*ec2.CreatePlacementGroupOutput) 3112 ret1, _ := ret[1].(error) 3113 return ret0, ret1 3114 } 3115 3116 // CreatePlacementGroupWithContext indicates an expected call of CreatePlacementGroupWithContext 3117 func (mr *MockEC2APIMockRecorder) CreatePlacementGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3118 mr.mock.ctrl.T.Helper() 3119 varargs := append([]interface{}{arg0, arg1}, arg2...) 3120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupWithContext), varargs...) 3121 } 3122 3123 // CreatePlacementGroupRequest mocks base method 3124 func (m *MockEC2API) CreatePlacementGroupRequest(arg0 *ec2.CreatePlacementGroupInput) (*request.Request, *ec2.CreatePlacementGroupOutput) { 3125 m.ctrl.T.Helper() 3126 ret := m.ctrl.Call(m, "CreatePlacementGroupRequest", arg0) 3127 ret0, _ := ret[0].(*request.Request) 3128 ret1, _ := ret[1].(*ec2.CreatePlacementGroupOutput) 3129 return ret0, ret1 3130 } 3131 3132 // CreatePlacementGroupRequest indicates an expected call of CreatePlacementGroupRequest 3133 func (mr *MockEC2APIMockRecorder) CreatePlacementGroupRequest(arg0 interface{}) *gomock.Call { 3134 mr.mock.ctrl.T.Helper() 3135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreatePlacementGroupRequest), arg0) 3136 } 3137 3138 // CreateReservedInstancesListing mocks base method 3139 func (m *MockEC2API) CreateReservedInstancesListing(arg0 *ec2.CreateReservedInstancesListingInput) (*ec2.CreateReservedInstancesListingOutput, error) { 3140 m.ctrl.T.Helper() 3141 ret := m.ctrl.Call(m, "CreateReservedInstancesListing", arg0) 3142 ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput) 3143 ret1, _ := ret[1].(error) 3144 return ret0, ret1 3145 } 3146 3147 // CreateReservedInstancesListing indicates an expected call of CreateReservedInstancesListing 3148 func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListing(arg0 interface{}) *gomock.Call { 3149 mr.mock.ctrl.T.Helper() 3150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListing", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListing), arg0) 3151 } 3152 3153 // CreateReservedInstancesListingWithContext mocks base method 3154 func (m *MockEC2API) CreateReservedInstancesListingWithContext(arg0 aws.Context, arg1 *ec2.CreateReservedInstancesListingInput, arg2 ...request.Option) (*ec2.CreateReservedInstancesListingOutput, error) { 3155 m.ctrl.T.Helper() 3156 varargs := []interface{}{arg0, arg1} 3157 for _, a := range arg2 { 3158 varargs = append(varargs, a) 3159 } 3160 ret := m.ctrl.Call(m, "CreateReservedInstancesListingWithContext", varargs...) 3161 ret0, _ := ret[0].(*ec2.CreateReservedInstancesListingOutput) 3162 ret1, _ := ret[1].(error) 3163 return ret0, ret1 3164 } 3165 3166 // CreateReservedInstancesListingWithContext indicates an expected call of CreateReservedInstancesListingWithContext 3167 func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3168 mr.mock.ctrl.T.Helper() 3169 varargs := append([]interface{}{arg0, arg1}, arg2...) 3170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingWithContext), varargs...) 3171 } 3172 3173 // CreateReservedInstancesListingRequest mocks base method 3174 func (m *MockEC2API) CreateReservedInstancesListingRequest(arg0 *ec2.CreateReservedInstancesListingInput) (*request.Request, *ec2.CreateReservedInstancesListingOutput) { 3175 m.ctrl.T.Helper() 3176 ret := m.ctrl.Call(m, "CreateReservedInstancesListingRequest", arg0) 3177 ret0, _ := ret[0].(*request.Request) 3178 ret1, _ := ret[1].(*ec2.CreateReservedInstancesListingOutput) 3179 return ret0, ret1 3180 } 3181 3182 // CreateReservedInstancesListingRequest indicates an expected call of CreateReservedInstancesListingRequest 3183 func (mr *MockEC2APIMockRecorder) CreateReservedInstancesListingRequest(arg0 interface{}) *gomock.Call { 3184 mr.mock.ctrl.T.Helper() 3185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateReservedInstancesListingRequest", reflect.TypeOf((*MockEC2API)(nil).CreateReservedInstancesListingRequest), arg0) 3186 } 3187 3188 // CreateRoute mocks base method 3189 func (m *MockEC2API) CreateRoute(arg0 *ec2.CreateRouteInput) (*ec2.CreateRouteOutput, error) { 3190 m.ctrl.T.Helper() 3191 ret := m.ctrl.Call(m, "CreateRoute", arg0) 3192 ret0, _ := ret[0].(*ec2.CreateRouteOutput) 3193 ret1, _ := ret[1].(error) 3194 return ret0, ret1 3195 } 3196 3197 // CreateRoute indicates an expected call of CreateRoute 3198 func (mr *MockEC2APIMockRecorder) CreateRoute(arg0 interface{}) *gomock.Call { 3199 mr.mock.ctrl.T.Helper() 3200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRoute", reflect.TypeOf((*MockEC2API)(nil).CreateRoute), arg0) 3201 } 3202 3203 // CreateRouteWithContext mocks base method 3204 func (m *MockEC2API) CreateRouteWithContext(arg0 aws.Context, arg1 *ec2.CreateRouteInput, arg2 ...request.Option) (*ec2.CreateRouteOutput, error) { 3205 m.ctrl.T.Helper() 3206 varargs := []interface{}{arg0, arg1} 3207 for _, a := range arg2 { 3208 varargs = append(varargs, a) 3209 } 3210 ret := m.ctrl.Call(m, "CreateRouteWithContext", varargs...) 3211 ret0, _ := ret[0].(*ec2.CreateRouteOutput) 3212 ret1, _ := ret[1].(error) 3213 return ret0, ret1 3214 } 3215 3216 // CreateRouteWithContext indicates an expected call of CreateRouteWithContext 3217 func (mr *MockEC2APIMockRecorder) CreateRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3218 mr.mock.ctrl.T.Helper() 3219 varargs := append([]interface{}{arg0, arg1}, arg2...) 3220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateRouteWithContext), varargs...) 3221 } 3222 3223 // CreateRouteRequest mocks base method 3224 func (m *MockEC2API) CreateRouteRequest(arg0 *ec2.CreateRouteInput) (*request.Request, *ec2.CreateRouteOutput) { 3225 m.ctrl.T.Helper() 3226 ret := m.ctrl.Call(m, "CreateRouteRequest", arg0) 3227 ret0, _ := ret[0].(*request.Request) 3228 ret1, _ := ret[1].(*ec2.CreateRouteOutput) 3229 return ret0, ret1 3230 } 3231 3232 // CreateRouteRequest indicates an expected call of CreateRouteRequest 3233 func (mr *MockEC2APIMockRecorder) CreateRouteRequest(arg0 interface{}) *gomock.Call { 3234 mr.mock.ctrl.T.Helper() 3235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteRequest), arg0) 3236 } 3237 3238 // CreateRouteTable mocks base method 3239 func (m *MockEC2API) CreateRouteTable(arg0 *ec2.CreateRouteTableInput) (*ec2.CreateRouteTableOutput, error) { 3240 m.ctrl.T.Helper() 3241 ret := m.ctrl.Call(m, "CreateRouteTable", arg0) 3242 ret0, _ := ret[0].(*ec2.CreateRouteTableOutput) 3243 ret1, _ := ret[1].(error) 3244 return ret0, ret1 3245 } 3246 3247 // CreateRouteTable indicates an expected call of CreateRouteTable 3248 func (mr *MockEC2APIMockRecorder) CreateRouteTable(arg0 interface{}) *gomock.Call { 3249 mr.mock.ctrl.T.Helper() 3250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTable), arg0) 3251 } 3252 3253 // CreateRouteTableWithContext mocks base method 3254 func (m *MockEC2API) CreateRouteTableWithContext(arg0 aws.Context, arg1 *ec2.CreateRouteTableInput, arg2 ...request.Option) (*ec2.CreateRouteTableOutput, error) { 3255 m.ctrl.T.Helper() 3256 varargs := []interface{}{arg0, arg1} 3257 for _, a := range arg2 { 3258 varargs = append(varargs, a) 3259 } 3260 ret := m.ctrl.Call(m, "CreateRouteTableWithContext", varargs...) 3261 ret0, _ := ret[0].(*ec2.CreateRouteTableOutput) 3262 ret1, _ := ret[1].(error) 3263 return ret0, ret1 3264 } 3265 3266 // CreateRouteTableWithContext indicates an expected call of CreateRouteTableWithContext 3267 func (mr *MockEC2APIMockRecorder) CreateRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3268 mr.mock.ctrl.T.Helper() 3269 varargs := append([]interface{}{arg0, arg1}, arg2...) 3270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTableWithContext), varargs...) 3271 } 3272 3273 // CreateRouteTableRequest mocks base method 3274 func (m *MockEC2API) CreateRouteTableRequest(arg0 *ec2.CreateRouteTableInput) (*request.Request, *ec2.CreateRouteTableOutput) { 3275 m.ctrl.T.Helper() 3276 ret := m.ctrl.Call(m, "CreateRouteTableRequest", arg0) 3277 ret0, _ := ret[0].(*request.Request) 3278 ret1, _ := ret[1].(*ec2.CreateRouteTableOutput) 3279 return ret0, ret1 3280 } 3281 3282 // CreateRouteTableRequest indicates an expected call of CreateRouteTableRequest 3283 func (mr *MockEC2APIMockRecorder) CreateRouteTableRequest(arg0 interface{}) *gomock.Call { 3284 mr.mock.ctrl.T.Helper() 3285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateRouteTableRequest), arg0) 3286 } 3287 3288 // CreateSecurityGroup mocks base method 3289 func (m *MockEC2API) CreateSecurityGroup(arg0 *ec2.CreateSecurityGroupInput) (*ec2.CreateSecurityGroupOutput, error) { 3290 m.ctrl.T.Helper() 3291 ret := m.ctrl.Call(m, "CreateSecurityGroup", arg0) 3292 ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput) 3293 ret1, _ := ret[1].(error) 3294 return ret0, ret1 3295 } 3296 3297 // CreateSecurityGroup indicates an expected call of CreateSecurityGroup 3298 func (mr *MockEC2APIMockRecorder) CreateSecurityGroup(arg0 interface{}) *gomock.Call { 3299 mr.mock.ctrl.T.Helper() 3300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroup), arg0) 3301 } 3302 3303 // CreateSecurityGroupWithContext mocks base method 3304 func (m *MockEC2API) CreateSecurityGroupWithContext(arg0 aws.Context, arg1 *ec2.CreateSecurityGroupInput, arg2 ...request.Option) (*ec2.CreateSecurityGroupOutput, error) { 3305 m.ctrl.T.Helper() 3306 varargs := []interface{}{arg0, arg1} 3307 for _, a := range arg2 { 3308 varargs = append(varargs, a) 3309 } 3310 ret := m.ctrl.Call(m, "CreateSecurityGroupWithContext", varargs...) 3311 ret0, _ := ret[0].(*ec2.CreateSecurityGroupOutput) 3312 ret1, _ := ret[1].(error) 3313 return ret0, ret1 3314 } 3315 3316 // CreateSecurityGroupWithContext indicates an expected call of CreateSecurityGroupWithContext 3317 func (mr *MockEC2APIMockRecorder) CreateSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3318 mr.mock.ctrl.T.Helper() 3319 varargs := append([]interface{}{arg0, arg1}, arg2...) 3320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroupWithContext), varargs...) 3321 } 3322 3323 // CreateSecurityGroupRequest mocks base method 3324 func (m *MockEC2API) CreateSecurityGroupRequest(arg0 *ec2.CreateSecurityGroupInput) (*request.Request, *ec2.CreateSecurityGroupOutput) { 3325 m.ctrl.T.Helper() 3326 ret := m.ctrl.Call(m, "CreateSecurityGroupRequest", arg0) 3327 ret0, _ := ret[0].(*request.Request) 3328 ret1, _ := ret[1].(*ec2.CreateSecurityGroupOutput) 3329 return ret0, ret1 3330 } 3331 3332 // CreateSecurityGroupRequest indicates an expected call of CreateSecurityGroupRequest 3333 func (mr *MockEC2APIMockRecorder) CreateSecurityGroupRequest(arg0 interface{}) *gomock.Call { 3334 mr.mock.ctrl.T.Helper() 3335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSecurityGroupRequest), arg0) 3336 } 3337 3338 // CreateSnapshot mocks base method 3339 func (m *MockEC2API) CreateSnapshot(arg0 *ec2.CreateSnapshotInput) (*ec2.Snapshot, error) { 3340 m.ctrl.T.Helper() 3341 ret := m.ctrl.Call(m, "CreateSnapshot", arg0) 3342 ret0, _ := ret[0].(*ec2.Snapshot) 3343 ret1, _ := ret[1].(error) 3344 return ret0, ret1 3345 } 3346 3347 // CreateSnapshot indicates an expected call of CreateSnapshot 3348 func (mr *MockEC2APIMockRecorder) CreateSnapshot(arg0 interface{}) *gomock.Call { 3349 mr.mock.ctrl.T.Helper() 3350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshot", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshot), arg0) 3351 } 3352 3353 // CreateSnapshotWithContext mocks base method 3354 func (m *MockEC2API) CreateSnapshotWithContext(arg0 aws.Context, arg1 *ec2.CreateSnapshotInput, arg2 ...request.Option) (*ec2.Snapshot, error) { 3355 m.ctrl.T.Helper() 3356 varargs := []interface{}{arg0, arg1} 3357 for _, a := range arg2 { 3358 varargs = append(varargs, a) 3359 } 3360 ret := m.ctrl.Call(m, "CreateSnapshotWithContext", varargs...) 3361 ret0, _ := ret[0].(*ec2.Snapshot) 3362 ret1, _ := ret[1].(error) 3363 return ret0, ret1 3364 } 3365 3366 // CreateSnapshotWithContext indicates an expected call of CreateSnapshotWithContext 3367 func (mr *MockEC2APIMockRecorder) CreateSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3368 mr.mock.ctrl.T.Helper() 3369 varargs := append([]interface{}{arg0, arg1}, arg2...) 3370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotWithContext), varargs...) 3371 } 3372 3373 // CreateSnapshotRequest mocks base method 3374 func (m *MockEC2API) CreateSnapshotRequest(arg0 *ec2.CreateSnapshotInput) (*request.Request, *ec2.Snapshot) { 3375 m.ctrl.T.Helper() 3376 ret := m.ctrl.Call(m, "CreateSnapshotRequest", arg0) 3377 ret0, _ := ret[0].(*request.Request) 3378 ret1, _ := ret[1].(*ec2.Snapshot) 3379 return ret0, ret1 3380 } 3381 3382 // CreateSnapshotRequest indicates an expected call of CreateSnapshotRequest 3383 func (mr *MockEC2APIMockRecorder) CreateSnapshotRequest(arg0 interface{}) *gomock.Call { 3384 mr.mock.ctrl.T.Helper() 3385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotRequest), arg0) 3386 } 3387 3388 // CreateSnapshots mocks base method 3389 func (m *MockEC2API) CreateSnapshots(arg0 *ec2.CreateSnapshotsInput) (*ec2.CreateSnapshotsOutput, error) { 3390 m.ctrl.T.Helper() 3391 ret := m.ctrl.Call(m, "CreateSnapshots", arg0) 3392 ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput) 3393 ret1, _ := ret[1].(error) 3394 return ret0, ret1 3395 } 3396 3397 // CreateSnapshots indicates an expected call of CreateSnapshots 3398 func (mr *MockEC2APIMockRecorder) CreateSnapshots(arg0 interface{}) *gomock.Call { 3399 mr.mock.ctrl.T.Helper() 3400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshots", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshots), arg0) 3401 } 3402 3403 // CreateSnapshotsWithContext mocks base method 3404 func (m *MockEC2API) CreateSnapshotsWithContext(arg0 aws.Context, arg1 *ec2.CreateSnapshotsInput, arg2 ...request.Option) (*ec2.CreateSnapshotsOutput, error) { 3405 m.ctrl.T.Helper() 3406 varargs := []interface{}{arg0, arg1} 3407 for _, a := range arg2 { 3408 varargs = append(varargs, a) 3409 } 3410 ret := m.ctrl.Call(m, "CreateSnapshotsWithContext", varargs...) 3411 ret0, _ := ret[0].(*ec2.CreateSnapshotsOutput) 3412 ret1, _ := ret[1].(error) 3413 return ret0, ret1 3414 } 3415 3416 // CreateSnapshotsWithContext indicates an expected call of CreateSnapshotsWithContext 3417 func (mr *MockEC2APIMockRecorder) CreateSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3418 mr.mock.ctrl.T.Helper() 3419 varargs := append([]interface{}{arg0, arg1}, arg2...) 3420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotsWithContext), varargs...) 3421 } 3422 3423 // CreateSnapshotsRequest mocks base method 3424 func (m *MockEC2API) CreateSnapshotsRequest(arg0 *ec2.CreateSnapshotsInput) (*request.Request, *ec2.CreateSnapshotsOutput) { 3425 m.ctrl.T.Helper() 3426 ret := m.ctrl.Call(m, "CreateSnapshotsRequest", arg0) 3427 ret0, _ := ret[0].(*request.Request) 3428 ret1, _ := ret[1].(*ec2.CreateSnapshotsOutput) 3429 return ret0, ret1 3430 } 3431 3432 // CreateSnapshotsRequest indicates an expected call of CreateSnapshotsRequest 3433 func (mr *MockEC2APIMockRecorder) CreateSnapshotsRequest(arg0 interface{}) *gomock.Call { 3434 mr.mock.ctrl.T.Helper() 3435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSnapshotsRequest), arg0) 3436 } 3437 3438 // CreateSpotDatafeedSubscription mocks base method 3439 func (m *MockEC2API) CreateSpotDatafeedSubscription(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) { 3440 m.ctrl.T.Helper() 3441 ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscription", arg0) 3442 ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput) 3443 ret1, _ := ret[1].(error) 3444 return ret0, ret1 3445 } 3446 3447 // CreateSpotDatafeedSubscription indicates an expected call of CreateSpotDatafeedSubscription 3448 func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { 3449 mr.mock.ctrl.T.Helper() 3450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscription), arg0) 3451 } 3452 3453 // CreateSpotDatafeedSubscriptionWithContext mocks base method 3454 func (m *MockEC2API) CreateSpotDatafeedSubscriptionWithContext(arg0 aws.Context, arg1 *ec2.CreateSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.CreateSpotDatafeedSubscriptionOutput, error) { 3455 m.ctrl.T.Helper() 3456 varargs := []interface{}{arg0, arg1} 3457 for _, a := range arg2 { 3458 varargs = append(varargs, a) 3459 } 3460 ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionWithContext", varargs...) 3461 ret0, _ := ret[0].(*ec2.CreateSpotDatafeedSubscriptionOutput) 3462 ret1, _ := ret[1].(error) 3463 return ret0, ret1 3464 } 3465 3466 // CreateSpotDatafeedSubscriptionWithContext indicates an expected call of CreateSpotDatafeedSubscriptionWithContext 3467 func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3468 mr.mock.ctrl.T.Helper() 3469 varargs := append([]interface{}{arg0, arg1}, arg2...) 3470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionWithContext), varargs...) 3471 } 3472 3473 // CreateSpotDatafeedSubscriptionRequest mocks base method 3474 func (m *MockEC2API) CreateSpotDatafeedSubscriptionRequest(arg0 *ec2.CreateSpotDatafeedSubscriptionInput) (*request.Request, *ec2.CreateSpotDatafeedSubscriptionOutput) { 3475 m.ctrl.T.Helper() 3476 ret := m.ctrl.Call(m, "CreateSpotDatafeedSubscriptionRequest", arg0) 3477 ret0, _ := ret[0].(*request.Request) 3478 ret1, _ := ret[1].(*ec2.CreateSpotDatafeedSubscriptionOutput) 3479 return ret0, ret1 3480 } 3481 3482 // CreateSpotDatafeedSubscriptionRequest indicates an expected call of CreateSpotDatafeedSubscriptionRequest 3483 func (mr *MockEC2APIMockRecorder) CreateSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { 3484 mr.mock.ctrl.T.Helper() 3485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSpotDatafeedSubscriptionRequest), arg0) 3486 } 3487 3488 // CreateSubnet mocks base method 3489 func (m *MockEC2API) CreateSubnet(arg0 *ec2.CreateSubnetInput) (*ec2.CreateSubnetOutput, error) { 3490 m.ctrl.T.Helper() 3491 ret := m.ctrl.Call(m, "CreateSubnet", arg0) 3492 ret0, _ := ret[0].(*ec2.CreateSubnetOutput) 3493 ret1, _ := ret[1].(error) 3494 return ret0, ret1 3495 } 3496 3497 // CreateSubnet indicates an expected call of CreateSubnet 3498 func (mr *MockEC2APIMockRecorder) CreateSubnet(arg0 interface{}) *gomock.Call { 3499 mr.mock.ctrl.T.Helper() 3500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnet", reflect.TypeOf((*MockEC2API)(nil).CreateSubnet), arg0) 3501 } 3502 3503 // CreateSubnetWithContext mocks base method 3504 func (m *MockEC2API) CreateSubnetWithContext(arg0 aws.Context, arg1 *ec2.CreateSubnetInput, arg2 ...request.Option) (*ec2.CreateSubnetOutput, error) { 3505 m.ctrl.T.Helper() 3506 varargs := []interface{}{arg0, arg1} 3507 for _, a := range arg2 { 3508 varargs = append(varargs, a) 3509 } 3510 ret := m.ctrl.Call(m, "CreateSubnetWithContext", varargs...) 3511 ret0, _ := ret[0].(*ec2.CreateSubnetOutput) 3512 ret1, _ := ret[1].(error) 3513 return ret0, ret1 3514 } 3515 3516 // CreateSubnetWithContext indicates an expected call of CreateSubnetWithContext 3517 func (mr *MockEC2APIMockRecorder) CreateSubnetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3518 mr.mock.ctrl.T.Helper() 3519 varargs := append([]interface{}{arg0, arg1}, arg2...) 3520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetWithContext), varargs...) 3521 } 3522 3523 // CreateSubnetRequest mocks base method 3524 func (m *MockEC2API) CreateSubnetRequest(arg0 *ec2.CreateSubnetInput) (*request.Request, *ec2.CreateSubnetOutput) { 3525 m.ctrl.T.Helper() 3526 ret := m.ctrl.Call(m, "CreateSubnetRequest", arg0) 3527 ret0, _ := ret[0].(*request.Request) 3528 ret1, _ := ret[1].(*ec2.CreateSubnetOutput) 3529 return ret0, ret1 3530 } 3531 3532 // CreateSubnetRequest indicates an expected call of CreateSubnetRequest 3533 func (mr *MockEC2APIMockRecorder) CreateSubnetRequest(arg0 interface{}) *gomock.Call { 3534 mr.mock.ctrl.T.Helper() 3535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateSubnetRequest), arg0) 3536 } 3537 3538 // CreateTags mocks base method 3539 func (m *MockEC2API) CreateTags(arg0 *ec2.CreateTagsInput) (*ec2.CreateTagsOutput, error) { 3540 m.ctrl.T.Helper() 3541 ret := m.ctrl.Call(m, "CreateTags", arg0) 3542 ret0, _ := ret[0].(*ec2.CreateTagsOutput) 3543 ret1, _ := ret[1].(error) 3544 return ret0, ret1 3545 } 3546 3547 // CreateTags indicates an expected call of CreateTags 3548 func (mr *MockEC2APIMockRecorder) CreateTags(arg0 interface{}) *gomock.Call { 3549 mr.mock.ctrl.T.Helper() 3550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTags", reflect.TypeOf((*MockEC2API)(nil).CreateTags), arg0) 3551 } 3552 3553 // CreateTagsWithContext mocks base method 3554 func (m *MockEC2API) CreateTagsWithContext(arg0 aws.Context, arg1 *ec2.CreateTagsInput, arg2 ...request.Option) (*ec2.CreateTagsOutput, error) { 3555 m.ctrl.T.Helper() 3556 varargs := []interface{}{arg0, arg1} 3557 for _, a := range arg2 { 3558 varargs = append(varargs, a) 3559 } 3560 ret := m.ctrl.Call(m, "CreateTagsWithContext", varargs...) 3561 ret0, _ := ret[0].(*ec2.CreateTagsOutput) 3562 ret1, _ := ret[1].(error) 3563 return ret0, ret1 3564 } 3565 3566 // CreateTagsWithContext indicates an expected call of CreateTagsWithContext 3567 func (mr *MockEC2APIMockRecorder) CreateTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3568 mr.mock.ctrl.T.Helper() 3569 varargs := append([]interface{}{arg0, arg1}, arg2...) 3570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTagsWithContext), varargs...) 3571 } 3572 3573 // CreateTagsRequest mocks base method 3574 func (m *MockEC2API) CreateTagsRequest(arg0 *ec2.CreateTagsInput) (*request.Request, *ec2.CreateTagsOutput) { 3575 m.ctrl.T.Helper() 3576 ret := m.ctrl.Call(m, "CreateTagsRequest", arg0) 3577 ret0, _ := ret[0].(*request.Request) 3578 ret1, _ := ret[1].(*ec2.CreateTagsOutput) 3579 return ret0, ret1 3580 } 3581 3582 // CreateTagsRequest indicates an expected call of CreateTagsRequest 3583 func (mr *MockEC2APIMockRecorder) CreateTagsRequest(arg0 interface{}) *gomock.Call { 3584 mr.mock.ctrl.T.Helper() 3585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTagsRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTagsRequest), arg0) 3586 } 3587 3588 // CreateTrafficMirrorFilter mocks base method 3589 func (m *MockEC2API) CreateTrafficMirrorFilter(arg0 *ec2.CreateTrafficMirrorFilterInput) (*ec2.CreateTrafficMirrorFilterOutput, error) { 3590 m.ctrl.T.Helper() 3591 ret := m.ctrl.Call(m, "CreateTrafficMirrorFilter", arg0) 3592 ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput) 3593 ret1, _ := ret[1].(error) 3594 return ret0, ret1 3595 } 3596 3597 // CreateTrafficMirrorFilter indicates an expected call of CreateTrafficMirrorFilter 3598 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilter(arg0 interface{}) *gomock.Call { 3599 mr.mock.ctrl.T.Helper() 3600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilter), arg0) 3601 } 3602 3603 // CreateTrafficMirrorFilterWithContext mocks base method 3604 func (m *MockEC2API) CreateTrafficMirrorFilterWithContext(arg0 aws.Context, arg1 *ec2.CreateTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterOutput, error) { 3605 m.ctrl.T.Helper() 3606 varargs := []interface{}{arg0, arg1} 3607 for _, a := range arg2 { 3608 varargs = append(varargs, a) 3609 } 3610 ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterWithContext", varargs...) 3611 ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterOutput) 3612 ret1, _ := ret[1].(error) 3613 return ret0, ret1 3614 } 3615 3616 // CreateTrafficMirrorFilterWithContext indicates an expected call of CreateTrafficMirrorFilterWithContext 3617 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3618 mr.mock.ctrl.T.Helper() 3619 varargs := append([]interface{}{arg0, arg1}, arg2...) 3620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterWithContext), varargs...) 3621 } 3622 3623 // CreateTrafficMirrorFilterRequest mocks base method 3624 func (m *MockEC2API) CreateTrafficMirrorFilterRequest(arg0 *ec2.CreateTrafficMirrorFilterInput) (*request.Request, *ec2.CreateTrafficMirrorFilterOutput) { 3625 m.ctrl.T.Helper() 3626 ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRequest", arg0) 3627 ret0, _ := ret[0].(*request.Request) 3628 ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterOutput) 3629 return ret0, ret1 3630 } 3631 3632 // CreateTrafficMirrorFilterRequest indicates an expected call of CreateTrafficMirrorFilterRequest 3633 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call { 3634 mr.mock.ctrl.T.Helper() 3635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRequest), arg0) 3636 } 3637 3638 // CreateTrafficMirrorFilterRule mocks base method 3639 func (m *MockEC2API) CreateTrafficMirrorFilterRule(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) { 3640 m.ctrl.T.Helper() 3641 ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRule", arg0) 3642 ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput) 3643 ret1, _ := ret[1].(error) 3644 return ret0, ret1 3645 } 3646 3647 // CreateTrafficMirrorFilterRule indicates an expected call of CreateTrafficMirrorFilterRule 3648 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { 3649 mr.mock.ctrl.T.Helper() 3650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRule), arg0) 3651 } 3652 3653 // CreateTrafficMirrorFilterRuleWithContext mocks base method 3654 func (m *MockEC2API) CreateTrafficMirrorFilterRuleWithContext(arg0 aws.Context, arg1 *ec2.CreateTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorFilterRuleOutput, error) { 3655 m.ctrl.T.Helper() 3656 varargs := []interface{}{arg0, arg1} 3657 for _, a := range arg2 { 3658 varargs = append(varargs, a) 3659 } 3660 ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleWithContext", varargs...) 3661 ret0, _ := ret[0].(*ec2.CreateTrafficMirrorFilterRuleOutput) 3662 ret1, _ := ret[1].(error) 3663 return ret0, ret1 3664 } 3665 3666 // CreateTrafficMirrorFilterRuleWithContext indicates an expected call of CreateTrafficMirrorFilterRuleWithContext 3667 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3668 mr.mock.ctrl.T.Helper() 3669 varargs := append([]interface{}{arg0, arg1}, arg2...) 3670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleWithContext), varargs...) 3671 } 3672 3673 // CreateTrafficMirrorFilterRuleRequest mocks base method 3674 func (m *MockEC2API) CreateTrafficMirrorFilterRuleRequest(arg0 *ec2.CreateTrafficMirrorFilterRuleInput) (*request.Request, *ec2.CreateTrafficMirrorFilterRuleOutput) { 3675 m.ctrl.T.Helper() 3676 ret := m.ctrl.Call(m, "CreateTrafficMirrorFilterRuleRequest", arg0) 3677 ret0, _ := ret[0].(*request.Request) 3678 ret1, _ := ret[1].(*ec2.CreateTrafficMirrorFilterRuleOutput) 3679 return ret0, ret1 3680 } 3681 3682 // CreateTrafficMirrorFilterRuleRequest indicates an expected call of CreateTrafficMirrorFilterRuleRequest 3683 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { 3684 mr.mock.ctrl.T.Helper() 3685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorFilterRuleRequest), arg0) 3686 } 3687 3688 // CreateTrafficMirrorSession mocks base method 3689 func (m *MockEC2API) CreateTrafficMirrorSession(arg0 *ec2.CreateTrafficMirrorSessionInput) (*ec2.CreateTrafficMirrorSessionOutput, error) { 3690 m.ctrl.T.Helper() 3691 ret := m.ctrl.Call(m, "CreateTrafficMirrorSession", arg0) 3692 ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput) 3693 ret1, _ := ret[1].(error) 3694 return ret0, ret1 3695 } 3696 3697 // CreateTrafficMirrorSession indicates an expected call of CreateTrafficMirrorSession 3698 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSession(arg0 interface{}) *gomock.Call { 3699 mr.mock.ctrl.T.Helper() 3700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSession), arg0) 3701 } 3702 3703 // CreateTrafficMirrorSessionWithContext mocks base method 3704 func (m *MockEC2API) CreateTrafficMirrorSessionWithContext(arg0 aws.Context, arg1 *ec2.CreateTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorSessionOutput, error) { 3705 m.ctrl.T.Helper() 3706 varargs := []interface{}{arg0, arg1} 3707 for _, a := range arg2 { 3708 varargs = append(varargs, a) 3709 } 3710 ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionWithContext", varargs...) 3711 ret0, _ := ret[0].(*ec2.CreateTrafficMirrorSessionOutput) 3712 ret1, _ := ret[1].(error) 3713 return ret0, ret1 3714 } 3715 3716 // CreateTrafficMirrorSessionWithContext indicates an expected call of CreateTrafficMirrorSessionWithContext 3717 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3718 mr.mock.ctrl.T.Helper() 3719 varargs := append([]interface{}{arg0, arg1}, arg2...) 3720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionWithContext), varargs...) 3721 } 3722 3723 // CreateTrafficMirrorSessionRequest mocks base method 3724 func (m *MockEC2API) CreateTrafficMirrorSessionRequest(arg0 *ec2.CreateTrafficMirrorSessionInput) (*request.Request, *ec2.CreateTrafficMirrorSessionOutput) { 3725 m.ctrl.T.Helper() 3726 ret := m.ctrl.Call(m, "CreateTrafficMirrorSessionRequest", arg0) 3727 ret0, _ := ret[0].(*request.Request) 3728 ret1, _ := ret[1].(*ec2.CreateTrafficMirrorSessionOutput) 3729 return ret0, ret1 3730 } 3731 3732 // CreateTrafficMirrorSessionRequest indicates an expected call of CreateTrafficMirrorSessionRequest 3733 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { 3734 mr.mock.ctrl.T.Helper() 3735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorSessionRequest), arg0) 3736 } 3737 3738 // CreateTrafficMirrorTarget mocks base method 3739 func (m *MockEC2API) CreateTrafficMirrorTarget(arg0 *ec2.CreateTrafficMirrorTargetInput) (*ec2.CreateTrafficMirrorTargetOutput, error) { 3740 m.ctrl.T.Helper() 3741 ret := m.ctrl.Call(m, "CreateTrafficMirrorTarget", arg0) 3742 ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput) 3743 ret1, _ := ret[1].(error) 3744 return ret0, ret1 3745 } 3746 3747 // CreateTrafficMirrorTarget indicates an expected call of CreateTrafficMirrorTarget 3748 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTarget(arg0 interface{}) *gomock.Call { 3749 mr.mock.ctrl.T.Helper() 3750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTarget), arg0) 3751 } 3752 3753 // CreateTrafficMirrorTargetWithContext mocks base method 3754 func (m *MockEC2API) CreateTrafficMirrorTargetWithContext(arg0 aws.Context, arg1 *ec2.CreateTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.CreateTrafficMirrorTargetOutput, error) { 3755 m.ctrl.T.Helper() 3756 varargs := []interface{}{arg0, arg1} 3757 for _, a := range arg2 { 3758 varargs = append(varargs, a) 3759 } 3760 ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetWithContext", varargs...) 3761 ret0, _ := ret[0].(*ec2.CreateTrafficMirrorTargetOutput) 3762 ret1, _ := ret[1].(error) 3763 return ret0, ret1 3764 } 3765 3766 // CreateTrafficMirrorTargetWithContext indicates an expected call of CreateTrafficMirrorTargetWithContext 3767 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3768 mr.mock.ctrl.T.Helper() 3769 varargs := append([]interface{}{arg0, arg1}, arg2...) 3770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetWithContext), varargs...) 3771 } 3772 3773 // CreateTrafficMirrorTargetRequest mocks base method 3774 func (m *MockEC2API) CreateTrafficMirrorTargetRequest(arg0 *ec2.CreateTrafficMirrorTargetInput) (*request.Request, *ec2.CreateTrafficMirrorTargetOutput) { 3775 m.ctrl.T.Helper() 3776 ret := m.ctrl.Call(m, "CreateTrafficMirrorTargetRequest", arg0) 3777 ret0, _ := ret[0].(*request.Request) 3778 ret1, _ := ret[1].(*ec2.CreateTrafficMirrorTargetOutput) 3779 return ret0, ret1 3780 } 3781 3782 // CreateTrafficMirrorTargetRequest indicates an expected call of CreateTrafficMirrorTargetRequest 3783 func (mr *MockEC2APIMockRecorder) CreateTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call { 3784 mr.mock.ctrl.T.Helper() 3785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTrafficMirrorTargetRequest), arg0) 3786 } 3787 3788 // CreateTransitGateway mocks base method 3789 func (m *MockEC2API) CreateTransitGateway(arg0 *ec2.CreateTransitGatewayInput) (*ec2.CreateTransitGatewayOutput, error) { 3790 m.ctrl.T.Helper() 3791 ret := m.ctrl.Call(m, "CreateTransitGateway", arg0) 3792 ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput) 3793 ret1, _ := ret[1].(error) 3794 return ret0, ret1 3795 } 3796 3797 // CreateTransitGateway indicates an expected call of CreateTransitGateway 3798 func (mr *MockEC2APIMockRecorder) CreateTransitGateway(arg0 interface{}) *gomock.Call { 3799 mr.mock.ctrl.T.Helper() 3800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGateway", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGateway), arg0) 3801 } 3802 3803 // CreateTransitGatewayWithContext mocks base method 3804 func (m *MockEC2API) CreateTransitGatewayWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayOutput, error) { 3805 m.ctrl.T.Helper() 3806 varargs := []interface{}{arg0, arg1} 3807 for _, a := range arg2 { 3808 varargs = append(varargs, a) 3809 } 3810 ret := m.ctrl.Call(m, "CreateTransitGatewayWithContext", varargs...) 3811 ret0, _ := ret[0].(*ec2.CreateTransitGatewayOutput) 3812 ret1, _ := ret[1].(error) 3813 return ret0, ret1 3814 } 3815 3816 // CreateTransitGatewayWithContext indicates an expected call of CreateTransitGatewayWithContext 3817 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3818 mr.mock.ctrl.T.Helper() 3819 varargs := append([]interface{}{arg0, arg1}, arg2...) 3820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayWithContext), varargs...) 3821 } 3822 3823 // CreateTransitGatewayRequest mocks base method 3824 func (m *MockEC2API) CreateTransitGatewayRequest(arg0 *ec2.CreateTransitGatewayInput) (*request.Request, *ec2.CreateTransitGatewayOutput) { 3825 m.ctrl.T.Helper() 3826 ret := m.ctrl.Call(m, "CreateTransitGatewayRequest", arg0) 3827 ret0, _ := ret[0].(*request.Request) 3828 ret1, _ := ret[1].(*ec2.CreateTransitGatewayOutput) 3829 return ret0, ret1 3830 } 3831 3832 // CreateTransitGatewayRequest indicates an expected call of CreateTransitGatewayRequest 3833 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRequest(arg0 interface{}) *gomock.Call { 3834 mr.mock.ctrl.T.Helper() 3835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRequest), arg0) 3836 } 3837 3838 // CreateTransitGatewayRoute mocks base method 3839 func (m *MockEC2API) CreateTransitGatewayRoute(arg0 *ec2.CreateTransitGatewayRouteInput) (*ec2.CreateTransitGatewayRouteOutput, error) { 3840 m.ctrl.T.Helper() 3841 ret := m.ctrl.Call(m, "CreateTransitGatewayRoute", arg0) 3842 ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput) 3843 ret1, _ := ret[1].(error) 3844 return ret0, ret1 3845 } 3846 3847 // CreateTransitGatewayRoute indicates an expected call of CreateTransitGatewayRoute 3848 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRoute(arg0 interface{}) *gomock.Call { 3849 mr.mock.ctrl.T.Helper() 3850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRoute), arg0) 3851 } 3852 3853 // CreateTransitGatewayRouteWithContext mocks base method 3854 func (m *MockEC2API) CreateTransitGatewayRouteWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteOutput, error) { 3855 m.ctrl.T.Helper() 3856 varargs := []interface{}{arg0, arg1} 3857 for _, a := range arg2 { 3858 varargs = append(varargs, a) 3859 } 3860 ret := m.ctrl.Call(m, "CreateTransitGatewayRouteWithContext", varargs...) 3861 ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteOutput) 3862 ret1, _ := ret[1].(error) 3863 return ret0, ret1 3864 } 3865 3866 // CreateTransitGatewayRouteWithContext indicates an expected call of CreateTransitGatewayRouteWithContext 3867 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3868 mr.mock.ctrl.T.Helper() 3869 varargs := append([]interface{}{arg0, arg1}, arg2...) 3870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteWithContext), varargs...) 3871 } 3872 3873 // CreateTransitGatewayRouteRequest mocks base method 3874 func (m *MockEC2API) CreateTransitGatewayRouteRequest(arg0 *ec2.CreateTransitGatewayRouteInput) (*request.Request, *ec2.CreateTransitGatewayRouteOutput) { 3875 m.ctrl.T.Helper() 3876 ret := m.ctrl.Call(m, "CreateTransitGatewayRouteRequest", arg0) 3877 ret0, _ := ret[0].(*request.Request) 3878 ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteOutput) 3879 return ret0, ret1 3880 } 3881 3882 // CreateTransitGatewayRouteRequest indicates an expected call of CreateTransitGatewayRouteRequest 3883 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { 3884 mr.mock.ctrl.T.Helper() 3885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteRequest), arg0) 3886 } 3887 3888 // CreateTransitGatewayRouteTable mocks base method 3889 func (m *MockEC2API) CreateTransitGatewayRouteTable(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*ec2.CreateTransitGatewayRouteTableOutput, error) { 3890 m.ctrl.T.Helper() 3891 ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTable", arg0) 3892 ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput) 3893 ret1, _ := ret[1].(error) 3894 return ret0, ret1 3895 } 3896 3897 // CreateTransitGatewayRouteTable indicates an expected call of CreateTransitGatewayRouteTable 3898 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { 3899 mr.mock.ctrl.T.Helper() 3900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTable), arg0) 3901 } 3902 3903 // CreateTransitGatewayRouteTableWithContext mocks base method 3904 func (m *MockEC2API) CreateTransitGatewayRouteTableWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayRouteTableOutput, error) { 3905 m.ctrl.T.Helper() 3906 varargs := []interface{}{arg0, arg1} 3907 for _, a := range arg2 { 3908 varargs = append(varargs, a) 3909 } 3910 ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableWithContext", varargs...) 3911 ret0, _ := ret[0].(*ec2.CreateTransitGatewayRouteTableOutput) 3912 ret1, _ := ret[1].(error) 3913 return ret0, ret1 3914 } 3915 3916 // CreateTransitGatewayRouteTableWithContext indicates an expected call of CreateTransitGatewayRouteTableWithContext 3917 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3918 mr.mock.ctrl.T.Helper() 3919 varargs := append([]interface{}{arg0, arg1}, arg2...) 3920 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableWithContext), varargs...) 3921 } 3922 3923 // CreateTransitGatewayRouteTableRequest mocks base method 3924 func (m *MockEC2API) CreateTransitGatewayRouteTableRequest(arg0 *ec2.CreateTransitGatewayRouteTableInput) (*request.Request, *ec2.CreateTransitGatewayRouteTableOutput) { 3925 m.ctrl.T.Helper() 3926 ret := m.ctrl.Call(m, "CreateTransitGatewayRouteTableRequest", arg0) 3927 ret0, _ := ret[0].(*request.Request) 3928 ret1, _ := ret[1].(*ec2.CreateTransitGatewayRouteTableOutput) 3929 return ret0, ret1 3930 } 3931 3932 // CreateTransitGatewayRouteTableRequest indicates an expected call of CreateTransitGatewayRouteTableRequest 3933 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { 3934 mr.mock.ctrl.T.Helper() 3935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayRouteTableRequest), arg0) 3936 } 3937 3938 // CreateTransitGatewayVpcAttachment mocks base method 3939 func (m *MockEC2API) CreateTransitGatewayVpcAttachment(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) { 3940 m.ctrl.T.Helper() 3941 ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachment", arg0) 3942 ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput) 3943 ret1, _ := ret[1].(error) 3944 return ret0, ret1 3945 } 3946 3947 // CreateTransitGatewayVpcAttachment indicates an expected call of CreateTransitGatewayVpcAttachment 3948 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { 3949 mr.mock.ctrl.T.Helper() 3950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachment), arg0) 3951 } 3952 3953 // CreateTransitGatewayVpcAttachmentWithContext mocks base method 3954 func (m *MockEC2API) CreateTransitGatewayVpcAttachmentWithContext(arg0 aws.Context, arg1 *ec2.CreateTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.CreateTransitGatewayVpcAttachmentOutput, error) { 3955 m.ctrl.T.Helper() 3956 varargs := []interface{}{arg0, arg1} 3957 for _, a := range arg2 { 3958 varargs = append(varargs, a) 3959 } 3960 ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentWithContext", varargs...) 3961 ret0, _ := ret[0].(*ec2.CreateTransitGatewayVpcAttachmentOutput) 3962 ret1, _ := ret[1].(error) 3963 return ret0, ret1 3964 } 3965 3966 // CreateTransitGatewayVpcAttachmentWithContext indicates an expected call of CreateTransitGatewayVpcAttachmentWithContext 3967 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 3968 mr.mock.ctrl.T.Helper() 3969 varargs := append([]interface{}{arg0, arg1}, arg2...) 3970 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentWithContext), varargs...) 3971 } 3972 3973 // CreateTransitGatewayVpcAttachmentRequest mocks base method 3974 func (m *MockEC2API) CreateTransitGatewayVpcAttachmentRequest(arg0 *ec2.CreateTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.CreateTransitGatewayVpcAttachmentOutput) { 3975 m.ctrl.T.Helper() 3976 ret := m.ctrl.Call(m, "CreateTransitGatewayVpcAttachmentRequest", arg0) 3977 ret0, _ := ret[0].(*request.Request) 3978 ret1, _ := ret[1].(*ec2.CreateTransitGatewayVpcAttachmentOutput) 3979 return ret0, ret1 3980 } 3981 3982 // CreateTransitGatewayVpcAttachmentRequest indicates an expected call of CreateTransitGatewayVpcAttachmentRequest 3983 func (mr *MockEC2APIMockRecorder) CreateTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { 3984 mr.mock.ctrl.T.Helper() 3985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).CreateTransitGatewayVpcAttachmentRequest), arg0) 3986 } 3987 3988 // CreateVolume mocks base method 3989 func (m *MockEC2API) CreateVolume(arg0 *ec2.CreateVolumeInput) (*ec2.Volume, error) { 3990 m.ctrl.T.Helper() 3991 ret := m.ctrl.Call(m, "CreateVolume", arg0) 3992 ret0, _ := ret[0].(*ec2.Volume) 3993 ret1, _ := ret[1].(error) 3994 return ret0, ret1 3995 } 3996 3997 // CreateVolume indicates an expected call of CreateVolume 3998 func (mr *MockEC2APIMockRecorder) CreateVolume(arg0 interface{}) *gomock.Call { 3999 mr.mock.ctrl.T.Helper() 4000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockEC2API)(nil).CreateVolume), arg0) 4001 } 4002 4003 // CreateVolumeWithContext mocks base method 4004 func (m *MockEC2API) CreateVolumeWithContext(arg0 aws.Context, arg1 *ec2.CreateVolumeInput, arg2 ...request.Option) (*ec2.Volume, error) { 4005 m.ctrl.T.Helper() 4006 varargs := []interface{}{arg0, arg1} 4007 for _, a := range arg2 { 4008 varargs = append(varargs, a) 4009 } 4010 ret := m.ctrl.Call(m, "CreateVolumeWithContext", varargs...) 4011 ret0, _ := ret[0].(*ec2.Volume) 4012 ret1, _ := ret[1].(error) 4013 return ret0, ret1 4014 } 4015 4016 // CreateVolumeWithContext indicates an expected call of CreateVolumeWithContext 4017 func (mr *MockEC2APIMockRecorder) CreateVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4018 mr.mock.ctrl.T.Helper() 4019 varargs := append([]interface{}{arg0, arg1}, arg2...) 4020 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVolumeWithContext), varargs...) 4021 } 4022 4023 // CreateVolumeRequest mocks base method 4024 func (m *MockEC2API) CreateVolumeRequest(arg0 *ec2.CreateVolumeInput) (*request.Request, *ec2.Volume) { 4025 m.ctrl.T.Helper() 4026 ret := m.ctrl.Call(m, "CreateVolumeRequest", arg0) 4027 ret0, _ := ret[0].(*request.Request) 4028 ret1, _ := ret[1].(*ec2.Volume) 4029 return ret0, ret1 4030 } 4031 4032 // CreateVolumeRequest indicates an expected call of CreateVolumeRequest 4033 func (mr *MockEC2APIMockRecorder) CreateVolumeRequest(arg0 interface{}) *gomock.Call { 4034 mr.mock.ctrl.T.Helper() 4035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVolumeRequest), arg0) 4036 } 4037 4038 // CreateVpc mocks base method 4039 func (m *MockEC2API) CreateVpc(arg0 *ec2.CreateVpcInput) (*ec2.CreateVpcOutput, error) { 4040 m.ctrl.T.Helper() 4041 ret := m.ctrl.Call(m, "CreateVpc", arg0) 4042 ret0, _ := ret[0].(*ec2.CreateVpcOutput) 4043 ret1, _ := ret[1].(error) 4044 return ret0, ret1 4045 } 4046 4047 // CreateVpc indicates an expected call of CreateVpc 4048 func (mr *MockEC2APIMockRecorder) CreateVpc(arg0 interface{}) *gomock.Call { 4049 mr.mock.ctrl.T.Helper() 4050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpc", reflect.TypeOf((*MockEC2API)(nil).CreateVpc), arg0) 4051 } 4052 4053 // CreateVpcWithContext mocks base method 4054 func (m *MockEC2API) CreateVpcWithContext(arg0 aws.Context, arg1 *ec2.CreateVpcInput, arg2 ...request.Option) (*ec2.CreateVpcOutput, error) { 4055 m.ctrl.T.Helper() 4056 varargs := []interface{}{arg0, arg1} 4057 for _, a := range arg2 { 4058 varargs = append(varargs, a) 4059 } 4060 ret := m.ctrl.Call(m, "CreateVpcWithContext", varargs...) 4061 ret0, _ := ret[0].(*ec2.CreateVpcOutput) 4062 ret1, _ := ret[1].(error) 4063 return ret0, ret1 4064 } 4065 4066 // CreateVpcWithContext indicates an expected call of CreateVpcWithContext 4067 func (mr *MockEC2APIMockRecorder) CreateVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4068 mr.mock.ctrl.T.Helper() 4069 varargs := append([]interface{}{arg0, arg1}, arg2...) 4070 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcWithContext), varargs...) 4071 } 4072 4073 // CreateVpcRequest mocks base method 4074 func (m *MockEC2API) CreateVpcRequest(arg0 *ec2.CreateVpcInput) (*request.Request, *ec2.CreateVpcOutput) { 4075 m.ctrl.T.Helper() 4076 ret := m.ctrl.Call(m, "CreateVpcRequest", arg0) 4077 ret0, _ := ret[0].(*request.Request) 4078 ret1, _ := ret[1].(*ec2.CreateVpcOutput) 4079 return ret0, ret1 4080 } 4081 4082 // CreateVpcRequest indicates an expected call of CreateVpcRequest 4083 func (mr *MockEC2APIMockRecorder) CreateVpcRequest(arg0 interface{}) *gomock.Call { 4084 mr.mock.ctrl.T.Helper() 4085 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcRequest), arg0) 4086 } 4087 4088 // CreateVpcEndpoint mocks base method 4089 func (m *MockEC2API) CreateVpcEndpoint(arg0 *ec2.CreateVpcEndpointInput) (*ec2.CreateVpcEndpointOutput, error) { 4090 m.ctrl.T.Helper() 4091 ret := m.ctrl.Call(m, "CreateVpcEndpoint", arg0) 4092 ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput) 4093 ret1, _ := ret[1].(error) 4094 return ret0, ret1 4095 } 4096 4097 // CreateVpcEndpoint indicates an expected call of CreateVpcEndpoint 4098 func (mr *MockEC2APIMockRecorder) CreateVpcEndpoint(arg0 interface{}) *gomock.Call { 4099 mr.mock.ctrl.T.Helper() 4100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpoint), arg0) 4101 } 4102 4103 // CreateVpcEndpointWithContext mocks base method 4104 func (m *MockEC2API) CreateVpcEndpointWithContext(arg0 aws.Context, arg1 *ec2.CreateVpcEndpointInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointOutput, error) { 4105 m.ctrl.T.Helper() 4106 varargs := []interface{}{arg0, arg1} 4107 for _, a := range arg2 { 4108 varargs = append(varargs, a) 4109 } 4110 ret := m.ctrl.Call(m, "CreateVpcEndpointWithContext", varargs...) 4111 ret0, _ := ret[0].(*ec2.CreateVpcEndpointOutput) 4112 ret1, _ := ret[1].(error) 4113 return ret0, ret1 4114 } 4115 4116 // CreateVpcEndpointWithContext indicates an expected call of CreateVpcEndpointWithContext 4117 func (mr *MockEC2APIMockRecorder) CreateVpcEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4118 mr.mock.ctrl.T.Helper() 4119 varargs := append([]interface{}{arg0, arg1}, arg2...) 4120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointWithContext), varargs...) 4121 } 4122 4123 // CreateVpcEndpointRequest mocks base method 4124 func (m *MockEC2API) CreateVpcEndpointRequest(arg0 *ec2.CreateVpcEndpointInput) (*request.Request, *ec2.CreateVpcEndpointOutput) { 4125 m.ctrl.T.Helper() 4126 ret := m.ctrl.Call(m, "CreateVpcEndpointRequest", arg0) 4127 ret0, _ := ret[0].(*request.Request) 4128 ret1, _ := ret[1].(*ec2.CreateVpcEndpointOutput) 4129 return ret0, ret1 4130 } 4131 4132 // CreateVpcEndpointRequest indicates an expected call of CreateVpcEndpointRequest 4133 func (mr *MockEC2APIMockRecorder) CreateVpcEndpointRequest(arg0 interface{}) *gomock.Call { 4134 mr.mock.ctrl.T.Helper() 4135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointRequest), arg0) 4136 } 4137 4138 // CreateVpcEndpointConnectionNotification mocks base method 4139 func (m *MockEC2API) CreateVpcEndpointConnectionNotification(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) { 4140 m.ctrl.T.Helper() 4141 ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotification", arg0) 4142 ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput) 4143 ret1, _ := ret[1].(error) 4144 return ret0, ret1 4145 } 4146 4147 // CreateVpcEndpointConnectionNotification indicates an expected call of CreateVpcEndpointConnectionNotification 4148 func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call { 4149 mr.mock.ctrl.T.Helper() 4150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotification), arg0) 4151 } 4152 4153 // CreateVpcEndpointConnectionNotificationWithContext mocks base method 4154 func (m *MockEC2API) CreateVpcEndpointConnectionNotificationWithContext(arg0 aws.Context, arg1 *ec2.CreateVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointConnectionNotificationOutput, error) { 4155 m.ctrl.T.Helper() 4156 varargs := []interface{}{arg0, arg1} 4157 for _, a := range arg2 { 4158 varargs = append(varargs, a) 4159 } 4160 ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationWithContext", varargs...) 4161 ret0, _ := ret[0].(*ec2.CreateVpcEndpointConnectionNotificationOutput) 4162 ret1, _ := ret[1].(error) 4163 return ret0, ret1 4164 } 4165 4166 // CreateVpcEndpointConnectionNotificationWithContext indicates an expected call of CreateVpcEndpointConnectionNotificationWithContext 4167 func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4168 mr.mock.ctrl.T.Helper() 4169 varargs := append([]interface{}{arg0, arg1}, arg2...) 4170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotificationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationWithContext), varargs...) 4171 } 4172 4173 // CreateVpcEndpointConnectionNotificationRequest mocks base method 4174 func (m *MockEC2API) CreateVpcEndpointConnectionNotificationRequest(arg0 *ec2.CreateVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.CreateVpcEndpointConnectionNotificationOutput) { 4175 m.ctrl.T.Helper() 4176 ret := m.ctrl.Call(m, "CreateVpcEndpointConnectionNotificationRequest", arg0) 4177 ret0, _ := ret[0].(*request.Request) 4178 ret1, _ := ret[1].(*ec2.CreateVpcEndpointConnectionNotificationOutput) 4179 return ret0, ret1 4180 } 4181 4182 // CreateVpcEndpointConnectionNotificationRequest indicates an expected call of CreateVpcEndpointConnectionNotificationRequest 4183 func (mr *MockEC2APIMockRecorder) CreateVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call { 4184 mr.mock.ctrl.T.Helper() 4185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointConnectionNotificationRequest), arg0) 4186 } 4187 4188 // CreateVpcEndpointServiceConfiguration mocks base method 4189 func (m *MockEC2API) CreateVpcEndpointServiceConfiguration(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) { 4190 m.ctrl.T.Helper() 4191 ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfiguration", arg0) 4192 ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput) 4193 ret1, _ := ret[1].(error) 4194 return ret0, ret1 4195 } 4196 4197 // CreateVpcEndpointServiceConfiguration indicates an expected call of CreateVpcEndpointServiceConfiguration 4198 func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call { 4199 mr.mock.ctrl.T.Helper() 4200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfiguration), arg0) 4201 } 4202 4203 // CreateVpcEndpointServiceConfigurationWithContext mocks base method 4204 func (m *MockEC2API) CreateVpcEndpointServiceConfigurationWithContext(arg0 aws.Context, arg1 *ec2.CreateVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.CreateVpcEndpointServiceConfigurationOutput, error) { 4205 m.ctrl.T.Helper() 4206 varargs := []interface{}{arg0, arg1} 4207 for _, a := range arg2 { 4208 varargs = append(varargs, a) 4209 } 4210 ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationWithContext", varargs...) 4211 ret0, _ := ret[0].(*ec2.CreateVpcEndpointServiceConfigurationOutput) 4212 ret1, _ := ret[1].(error) 4213 return ret0, ret1 4214 } 4215 4216 // CreateVpcEndpointServiceConfigurationWithContext indicates an expected call of CreateVpcEndpointServiceConfigurationWithContext 4217 func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4218 mr.mock.ctrl.T.Helper() 4219 varargs := append([]interface{}{arg0, arg1}, arg2...) 4220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationWithContext), varargs...) 4221 } 4222 4223 // CreateVpcEndpointServiceConfigurationRequest mocks base method 4224 func (m *MockEC2API) CreateVpcEndpointServiceConfigurationRequest(arg0 *ec2.CreateVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.CreateVpcEndpointServiceConfigurationOutput) { 4225 m.ctrl.T.Helper() 4226 ret := m.ctrl.Call(m, "CreateVpcEndpointServiceConfigurationRequest", arg0) 4227 ret0, _ := ret[0].(*request.Request) 4228 ret1, _ := ret[1].(*ec2.CreateVpcEndpointServiceConfigurationOutput) 4229 return ret0, ret1 4230 } 4231 4232 // CreateVpcEndpointServiceConfigurationRequest indicates an expected call of CreateVpcEndpointServiceConfigurationRequest 4233 func (mr *MockEC2APIMockRecorder) CreateVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call { 4234 mr.mock.ctrl.T.Helper() 4235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcEndpointServiceConfigurationRequest), arg0) 4236 } 4237 4238 // CreateVpcPeeringConnection mocks base method 4239 func (m *MockEC2API) CreateVpcPeeringConnection(arg0 *ec2.CreateVpcPeeringConnectionInput) (*ec2.CreateVpcPeeringConnectionOutput, error) { 4240 m.ctrl.T.Helper() 4241 ret := m.ctrl.Call(m, "CreateVpcPeeringConnection", arg0) 4242 ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput) 4243 ret1, _ := ret[1].(error) 4244 return ret0, ret1 4245 } 4246 4247 // CreateVpcPeeringConnection indicates an expected call of CreateVpcPeeringConnection 4248 func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnection(arg0 interface{}) *gomock.Call { 4249 mr.mock.ctrl.T.Helper() 4250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnection), arg0) 4251 } 4252 4253 // CreateVpcPeeringConnectionWithContext mocks base method 4254 func (m *MockEC2API) CreateVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *ec2.CreateVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.CreateVpcPeeringConnectionOutput, error) { 4255 m.ctrl.T.Helper() 4256 varargs := []interface{}{arg0, arg1} 4257 for _, a := range arg2 { 4258 varargs = append(varargs, a) 4259 } 4260 ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionWithContext", varargs...) 4261 ret0, _ := ret[0].(*ec2.CreateVpcPeeringConnectionOutput) 4262 ret1, _ := ret[1].(error) 4263 return ret0, ret1 4264 } 4265 4266 // CreateVpcPeeringConnectionWithContext indicates an expected call of CreateVpcPeeringConnectionWithContext 4267 func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4268 mr.mock.ctrl.T.Helper() 4269 varargs := append([]interface{}{arg0, arg1}, arg2...) 4270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnectionWithContext), varargs...) 4271 } 4272 4273 // CreateVpcPeeringConnectionRequest mocks base method 4274 func (m *MockEC2API) CreateVpcPeeringConnectionRequest(arg0 *ec2.CreateVpcPeeringConnectionInput) (*request.Request, *ec2.CreateVpcPeeringConnectionOutput) { 4275 m.ctrl.T.Helper() 4276 ret := m.ctrl.Call(m, "CreateVpcPeeringConnectionRequest", arg0) 4277 ret0, _ := ret[0].(*request.Request) 4278 ret1, _ := ret[1].(*ec2.CreateVpcPeeringConnectionOutput) 4279 return ret0, ret1 4280 } 4281 4282 // CreateVpcPeeringConnectionRequest indicates an expected call of CreateVpcPeeringConnectionRequest 4283 func (mr *MockEC2APIMockRecorder) CreateVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { 4284 mr.mock.ctrl.T.Helper() 4285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpcPeeringConnectionRequest), arg0) 4286 } 4287 4288 // CreateVpnConnection mocks base method 4289 func (m *MockEC2API) CreateVpnConnection(arg0 *ec2.CreateVpnConnectionInput) (*ec2.CreateVpnConnectionOutput, error) { 4290 m.ctrl.T.Helper() 4291 ret := m.ctrl.Call(m, "CreateVpnConnection", arg0) 4292 ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput) 4293 ret1, _ := ret[1].(error) 4294 return ret0, ret1 4295 } 4296 4297 // CreateVpnConnection indicates an expected call of CreateVpnConnection 4298 func (mr *MockEC2APIMockRecorder) CreateVpnConnection(arg0 interface{}) *gomock.Call { 4299 mr.mock.ctrl.T.Helper() 4300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnection", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnection), arg0) 4301 } 4302 4303 // CreateVpnConnectionWithContext mocks base method 4304 func (m *MockEC2API) CreateVpnConnectionWithContext(arg0 aws.Context, arg1 *ec2.CreateVpnConnectionInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionOutput, error) { 4305 m.ctrl.T.Helper() 4306 varargs := []interface{}{arg0, arg1} 4307 for _, a := range arg2 { 4308 varargs = append(varargs, a) 4309 } 4310 ret := m.ctrl.Call(m, "CreateVpnConnectionWithContext", varargs...) 4311 ret0, _ := ret[0].(*ec2.CreateVpnConnectionOutput) 4312 ret1, _ := ret[1].(error) 4313 return ret0, ret1 4314 } 4315 4316 // CreateVpnConnectionWithContext indicates an expected call of CreateVpnConnectionWithContext 4317 func (mr *MockEC2APIMockRecorder) CreateVpnConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4318 mr.mock.ctrl.T.Helper() 4319 varargs := append([]interface{}{arg0, arg1}, arg2...) 4320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionWithContext), varargs...) 4321 } 4322 4323 // CreateVpnConnectionRequest mocks base method 4324 func (m *MockEC2API) CreateVpnConnectionRequest(arg0 *ec2.CreateVpnConnectionInput) (*request.Request, *ec2.CreateVpnConnectionOutput) { 4325 m.ctrl.T.Helper() 4326 ret := m.ctrl.Call(m, "CreateVpnConnectionRequest", arg0) 4327 ret0, _ := ret[0].(*request.Request) 4328 ret1, _ := ret[1].(*ec2.CreateVpnConnectionOutput) 4329 return ret0, ret1 4330 } 4331 4332 // CreateVpnConnectionRequest indicates an expected call of CreateVpnConnectionRequest 4333 func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRequest(arg0 interface{}) *gomock.Call { 4334 mr.mock.ctrl.T.Helper() 4335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRequest), arg0) 4336 } 4337 4338 // CreateVpnConnectionRoute mocks base method 4339 func (m *MockEC2API) CreateVpnConnectionRoute(arg0 *ec2.CreateVpnConnectionRouteInput) (*ec2.CreateVpnConnectionRouteOutput, error) { 4340 m.ctrl.T.Helper() 4341 ret := m.ctrl.Call(m, "CreateVpnConnectionRoute", arg0) 4342 ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput) 4343 ret1, _ := ret[1].(error) 4344 return ret0, ret1 4345 } 4346 4347 // CreateVpnConnectionRoute indicates an expected call of CreateVpnConnectionRoute 4348 func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRoute(arg0 interface{}) *gomock.Call { 4349 mr.mock.ctrl.T.Helper() 4350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRoute), arg0) 4351 } 4352 4353 // CreateVpnConnectionRouteWithContext mocks base method 4354 func (m *MockEC2API) CreateVpnConnectionRouteWithContext(arg0 aws.Context, arg1 *ec2.CreateVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.CreateVpnConnectionRouteOutput, error) { 4355 m.ctrl.T.Helper() 4356 varargs := []interface{}{arg0, arg1} 4357 for _, a := range arg2 { 4358 varargs = append(varargs, a) 4359 } 4360 ret := m.ctrl.Call(m, "CreateVpnConnectionRouteWithContext", varargs...) 4361 ret0, _ := ret[0].(*ec2.CreateVpnConnectionRouteOutput) 4362 ret1, _ := ret[1].(error) 4363 return ret0, ret1 4364 } 4365 4366 // CreateVpnConnectionRouteWithContext indicates an expected call of CreateVpnConnectionRouteWithContext 4367 func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4368 mr.mock.ctrl.T.Helper() 4369 varargs := append([]interface{}{arg0, arg1}, arg2...) 4370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRouteWithContext), varargs...) 4371 } 4372 4373 // CreateVpnConnectionRouteRequest mocks base method 4374 func (m *MockEC2API) CreateVpnConnectionRouteRequest(arg0 *ec2.CreateVpnConnectionRouteInput) (*request.Request, *ec2.CreateVpnConnectionRouteOutput) { 4375 m.ctrl.T.Helper() 4376 ret := m.ctrl.Call(m, "CreateVpnConnectionRouteRequest", arg0) 4377 ret0, _ := ret[0].(*request.Request) 4378 ret1, _ := ret[1].(*ec2.CreateVpnConnectionRouteOutput) 4379 return ret0, ret1 4380 } 4381 4382 // CreateVpnConnectionRouteRequest indicates an expected call of CreateVpnConnectionRouteRequest 4383 func (mr *MockEC2APIMockRecorder) CreateVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call { 4384 mr.mock.ctrl.T.Helper() 4385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnConnectionRouteRequest), arg0) 4386 } 4387 4388 // CreateVpnGateway mocks base method 4389 func (m *MockEC2API) CreateVpnGateway(arg0 *ec2.CreateVpnGatewayInput) (*ec2.CreateVpnGatewayOutput, error) { 4390 m.ctrl.T.Helper() 4391 ret := m.ctrl.Call(m, "CreateVpnGateway", arg0) 4392 ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput) 4393 ret1, _ := ret[1].(error) 4394 return ret0, ret1 4395 } 4396 4397 // CreateVpnGateway indicates an expected call of CreateVpnGateway 4398 func (mr *MockEC2APIMockRecorder) CreateVpnGateway(arg0 interface{}) *gomock.Call { 4399 mr.mock.ctrl.T.Helper() 4400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGateway", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGateway), arg0) 4401 } 4402 4403 // CreateVpnGatewayWithContext mocks base method 4404 func (m *MockEC2API) CreateVpnGatewayWithContext(arg0 aws.Context, arg1 *ec2.CreateVpnGatewayInput, arg2 ...request.Option) (*ec2.CreateVpnGatewayOutput, error) { 4405 m.ctrl.T.Helper() 4406 varargs := []interface{}{arg0, arg1} 4407 for _, a := range arg2 { 4408 varargs = append(varargs, a) 4409 } 4410 ret := m.ctrl.Call(m, "CreateVpnGatewayWithContext", varargs...) 4411 ret0, _ := ret[0].(*ec2.CreateVpnGatewayOutput) 4412 ret1, _ := ret[1].(error) 4413 return ret0, ret1 4414 } 4415 4416 // CreateVpnGatewayWithContext indicates an expected call of CreateVpnGatewayWithContext 4417 func (mr *MockEC2APIMockRecorder) CreateVpnGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4418 mr.mock.ctrl.T.Helper() 4419 varargs := append([]interface{}{arg0, arg1}, arg2...) 4420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGatewayWithContext), varargs...) 4421 } 4422 4423 // CreateVpnGatewayRequest mocks base method 4424 func (m *MockEC2API) CreateVpnGatewayRequest(arg0 *ec2.CreateVpnGatewayInput) (*request.Request, *ec2.CreateVpnGatewayOutput) { 4425 m.ctrl.T.Helper() 4426 ret := m.ctrl.Call(m, "CreateVpnGatewayRequest", arg0) 4427 ret0, _ := ret[0].(*request.Request) 4428 ret1, _ := ret[1].(*ec2.CreateVpnGatewayOutput) 4429 return ret0, ret1 4430 } 4431 4432 // CreateVpnGatewayRequest indicates an expected call of CreateVpnGatewayRequest 4433 func (mr *MockEC2APIMockRecorder) CreateVpnGatewayRequest(arg0 interface{}) *gomock.Call { 4434 mr.mock.ctrl.T.Helper() 4435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).CreateVpnGatewayRequest), arg0) 4436 } 4437 4438 // DeleteClientVpnEndpoint mocks base method 4439 func (m *MockEC2API) DeleteClientVpnEndpoint(arg0 *ec2.DeleteClientVpnEndpointInput) (*ec2.DeleteClientVpnEndpointOutput, error) { 4440 m.ctrl.T.Helper() 4441 ret := m.ctrl.Call(m, "DeleteClientVpnEndpoint", arg0) 4442 ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput) 4443 ret1, _ := ret[1].(error) 4444 return ret0, ret1 4445 } 4446 4447 // DeleteClientVpnEndpoint indicates an expected call of DeleteClientVpnEndpoint 4448 func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpoint(arg0 interface{}) *gomock.Call { 4449 mr.mock.ctrl.T.Helper() 4450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpoint), arg0) 4451 } 4452 4453 // DeleteClientVpnEndpointWithContext mocks base method 4454 func (m *MockEC2API) DeleteClientVpnEndpointWithContext(arg0 aws.Context, arg1 *ec2.DeleteClientVpnEndpointInput, arg2 ...request.Option) (*ec2.DeleteClientVpnEndpointOutput, error) { 4455 m.ctrl.T.Helper() 4456 varargs := []interface{}{arg0, arg1} 4457 for _, a := range arg2 { 4458 varargs = append(varargs, a) 4459 } 4460 ret := m.ctrl.Call(m, "DeleteClientVpnEndpointWithContext", varargs...) 4461 ret0, _ := ret[0].(*ec2.DeleteClientVpnEndpointOutput) 4462 ret1, _ := ret[1].(error) 4463 return ret0, ret1 4464 } 4465 4466 // DeleteClientVpnEndpointWithContext indicates an expected call of DeleteClientVpnEndpointWithContext 4467 func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4468 mr.mock.ctrl.T.Helper() 4469 varargs := append([]interface{}{arg0, arg1}, arg2...) 4470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpointWithContext), varargs...) 4471 } 4472 4473 // DeleteClientVpnEndpointRequest mocks base method 4474 func (m *MockEC2API) DeleteClientVpnEndpointRequest(arg0 *ec2.DeleteClientVpnEndpointInput) (*request.Request, *ec2.DeleteClientVpnEndpointOutput) { 4475 m.ctrl.T.Helper() 4476 ret := m.ctrl.Call(m, "DeleteClientVpnEndpointRequest", arg0) 4477 ret0, _ := ret[0].(*request.Request) 4478 ret1, _ := ret[1].(*ec2.DeleteClientVpnEndpointOutput) 4479 return ret0, ret1 4480 } 4481 4482 // DeleteClientVpnEndpointRequest indicates an expected call of DeleteClientVpnEndpointRequest 4483 func (mr *MockEC2APIMockRecorder) DeleteClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { 4484 mr.mock.ctrl.T.Helper() 4485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnEndpointRequest), arg0) 4486 } 4487 4488 // DeleteClientVpnRoute mocks base method 4489 func (m *MockEC2API) DeleteClientVpnRoute(arg0 *ec2.DeleteClientVpnRouteInput) (*ec2.DeleteClientVpnRouteOutput, error) { 4490 m.ctrl.T.Helper() 4491 ret := m.ctrl.Call(m, "DeleteClientVpnRoute", arg0) 4492 ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput) 4493 ret1, _ := ret[1].(error) 4494 return ret0, ret1 4495 } 4496 4497 // DeleteClientVpnRoute indicates an expected call of DeleteClientVpnRoute 4498 func (mr *MockEC2APIMockRecorder) DeleteClientVpnRoute(arg0 interface{}) *gomock.Call { 4499 mr.mock.ctrl.T.Helper() 4500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRoute), arg0) 4501 } 4502 4503 // DeleteClientVpnRouteWithContext mocks base method 4504 func (m *MockEC2API) DeleteClientVpnRouteWithContext(arg0 aws.Context, arg1 *ec2.DeleteClientVpnRouteInput, arg2 ...request.Option) (*ec2.DeleteClientVpnRouteOutput, error) { 4505 m.ctrl.T.Helper() 4506 varargs := []interface{}{arg0, arg1} 4507 for _, a := range arg2 { 4508 varargs = append(varargs, a) 4509 } 4510 ret := m.ctrl.Call(m, "DeleteClientVpnRouteWithContext", varargs...) 4511 ret0, _ := ret[0].(*ec2.DeleteClientVpnRouteOutput) 4512 ret1, _ := ret[1].(error) 4513 return ret0, ret1 4514 } 4515 4516 // DeleteClientVpnRouteWithContext indicates an expected call of DeleteClientVpnRouteWithContext 4517 func (mr *MockEC2APIMockRecorder) DeleteClientVpnRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4518 mr.mock.ctrl.T.Helper() 4519 varargs := append([]interface{}{arg0, arg1}, arg2...) 4520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRouteWithContext), varargs...) 4521 } 4522 4523 // DeleteClientVpnRouteRequest mocks base method 4524 func (m *MockEC2API) DeleteClientVpnRouteRequest(arg0 *ec2.DeleteClientVpnRouteInput) (*request.Request, *ec2.DeleteClientVpnRouteOutput) { 4525 m.ctrl.T.Helper() 4526 ret := m.ctrl.Call(m, "DeleteClientVpnRouteRequest", arg0) 4527 ret0, _ := ret[0].(*request.Request) 4528 ret1, _ := ret[1].(*ec2.DeleteClientVpnRouteOutput) 4529 return ret0, ret1 4530 } 4531 4532 // DeleteClientVpnRouteRequest indicates an expected call of DeleteClientVpnRouteRequest 4533 func (mr *MockEC2APIMockRecorder) DeleteClientVpnRouteRequest(arg0 interface{}) *gomock.Call { 4534 mr.mock.ctrl.T.Helper() 4535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteClientVpnRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteClientVpnRouteRequest), arg0) 4536 } 4537 4538 // DeleteCustomerGateway mocks base method 4539 func (m *MockEC2API) DeleteCustomerGateway(arg0 *ec2.DeleteCustomerGatewayInput) (*ec2.DeleteCustomerGatewayOutput, error) { 4540 m.ctrl.T.Helper() 4541 ret := m.ctrl.Call(m, "DeleteCustomerGateway", arg0) 4542 ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput) 4543 ret1, _ := ret[1].(error) 4544 return ret0, ret1 4545 } 4546 4547 // DeleteCustomerGateway indicates an expected call of DeleteCustomerGateway 4548 func (mr *MockEC2APIMockRecorder) DeleteCustomerGateway(arg0 interface{}) *gomock.Call { 4549 mr.mock.ctrl.T.Helper() 4550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGateway), arg0) 4551 } 4552 4553 // DeleteCustomerGatewayWithContext mocks base method 4554 func (m *MockEC2API) DeleteCustomerGatewayWithContext(arg0 aws.Context, arg1 *ec2.DeleteCustomerGatewayInput, arg2 ...request.Option) (*ec2.DeleteCustomerGatewayOutput, error) { 4555 m.ctrl.T.Helper() 4556 varargs := []interface{}{arg0, arg1} 4557 for _, a := range arg2 { 4558 varargs = append(varargs, a) 4559 } 4560 ret := m.ctrl.Call(m, "DeleteCustomerGatewayWithContext", varargs...) 4561 ret0, _ := ret[0].(*ec2.DeleteCustomerGatewayOutput) 4562 ret1, _ := ret[1].(error) 4563 return ret0, ret1 4564 } 4565 4566 // DeleteCustomerGatewayWithContext indicates an expected call of DeleteCustomerGatewayWithContext 4567 func (mr *MockEC2APIMockRecorder) DeleteCustomerGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4568 mr.mock.ctrl.T.Helper() 4569 varargs := append([]interface{}{arg0, arg1}, arg2...) 4570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGatewayWithContext), varargs...) 4571 } 4572 4573 // DeleteCustomerGatewayRequest mocks base method 4574 func (m *MockEC2API) DeleteCustomerGatewayRequest(arg0 *ec2.DeleteCustomerGatewayInput) (*request.Request, *ec2.DeleteCustomerGatewayOutput) { 4575 m.ctrl.T.Helper() 4576 ret := m.ctrl.Call(m, "DeleteCustomerGatewayRequest", arg0) 4577 ret0, _ := ret[0].(*request.Request) 4578 ret1, _ := ret[1].(*ec2.DeleteCustomerGatewayOutput) 4579 return ret0, ret1 4580 } 4581 4582 // DeleteCustomerGatewayRequest indicates an expected call of DeleteCustomerGatewayRequest 4583 func (mr *MockEC2APIMockRecorder) DeleteCustomerGatewayRequest(arg0 interface{}) *gomock.Call { 4584 mr.mock.ctrl.T.Helper() 4585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCustomerGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteCustomerGatewayRequest), arg0) 4586 } 4587 4588 // DeleteDhcpOptions mocks base method 4589 func (m *MockEC2API) DeleteDhcpOptions(arg0 *ec2.DeleteDhcpOptionsInput) (*ec2.DeleteDhcpOptionsOutput, error) { 4590 m.ctrl.T.Helper() 4591 ret := m.ctrl.Call(m, "DeleteDhcpOptions", arg0) 4592 ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput) 4593 ret1, _ := ret[1].(error) 4594 return ret0, ret1 4595 } 4596 4597 // DeleteDhcpOptions indicates an expected call of DeleteDhcpOptions 4598 func (mr *MockEC2APIMockRecorder) DeleteDhcpOptions(arg0 interface{}) *gomock.Call { 4599 mr.mock.ctrl.T.Helper() 4600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptions), arg0) 4601 } 4602 4603 // DeleteDhcpOptionsWithContext mocks base method 4604 func (m *MockEC2API) DeleteDhcpOptionsWithContext(arg0 aws.Context, arg1 *ec2.DeleteDhcpOptionsInput, arg2 ...request.Option) (*ec2.DeleteDhcpOptionsOutput, error) { 4605 m.ctrl.T.Helper() 4606 varargs := []interface{}{arg0, arg1} 4607 for _, a := range arg2 { 4608 varargs = append(varargs, a) 4609 } 4610 ret := m.ctrl.Call(m, "DeleteDhcpOptionsWithContext", varargs...) 4611 ret0, _ := ret[0].(*ec2.DeleteDhcpOptionsOutput) 4612 ret1, _ := ret[1].(error) 4613 return ret0, ret1 4614 } 4615 4616 // DeleteDhcpOptionsWithContext indicates an expected call of DeleteDhcpOptionsWithContext 4617 func (mr *MockEC2APIMockRecorder) DeleteDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4618 mr.mock.ctrl.T.Helper() 4619 varargs := append([]interface{}{arg0, arg1}, arg2...) 4620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptionsWithContext), varargs...) 4621 } 4622 4623 // DeleteDhcpOptionsRequest mocks base method 4624 func (m *MockEC2API) DeleteDhcpOptionsRequest(arg0 *ec2.DeleteDhcpOptionsInput) (*request.Request, *ec2.DeleteDhcpOptionsOutput) { 4625 m.ctrl.T.Helper() 4626 ret := m.ctrl.Call(m, "DeleteDhcpOptionsRequest", arg0) 4627 ret0, _ := ret[0].(*request.Request) 4628 ret1, _ := ret[1].(*ec2.DeleteDhcpOptionsOutput) 4629 return ret0, ret1 4630 } 4631 4632 // DeleteDhcpOptionsRequest indicates an expected call of DeleteDhcpOptionsRequest 4633 func (mr *MockEC2APIMockRecorder) DeleteDhcpOptionsRequest(arg0 interface{}) *gomock.Call { 4634 mr.mock.ctrl.T.Helper() 4635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteDhcpOptionsRequest), arg0) 4636 } 4637 4638 // DeleteEgressOnlyInternetGateway mocks base method 4639 func (m *MockEC2API) DeleteEgressOnlyInternetGateway(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) { 4640 m.ctrl.T.Helper() 4641 ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGateway", arg0) 4642 ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput) 4643 ret1, _ := ret[1].(error) 4644 return ret0, ret1 4645 } 4646 4647 // DeleteEgressOnlyInternetGateway indicates an expected call of DeleteEgressOnlyInternetGateway 4648 func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGateway(arg0 interface{}) *gomock.Call { 4649 mr.mock.ctrl.T.Helper() 4650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGateway), arg0) 4651 } 4652 4653 // DeleteEgressOnlyInternetGatewayWithContext mocks base method 4654 func (m *MockEC2API) DeleteEgressOnlyInternetGatewayWithContext(arg0 aws.Context, arg1 *ec2.DeleteEgressOnlyInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteEgressOnlyInternetGatewayOutput, error) { 4655 m.ctrl.T.Helper() 4656 varargs := []interface{}{arg0, arg1} 4657 for _, a := range arg2 { 4658 varargs = append(varargs, a) 4659 } 4660 ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayWithContext", varargs...) 4661 ret0, _ := ret[0].(*ec2.DeleteEgressOnlyInternetGatewayOutput) 4662 ret1, _ := ret[1].(error) 4663 return ret0, ret1 4664 } 4665 4666 // DeleteEgressOnlyInternetGatewayWithContext indicates an expected call of DeleteEgressOnlyInternetGatewayWithContext 4667 func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4668 mr.mock.ctrl.T.Helper() 4669 varargs := append([]interface{}{arg0, arg1}, arg2...) 4670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayWithContext), varargs...) 4671 } 4672 4673 // DeleteEgressOnlyInternetGatewayRequest mocks base method 4674 func (m *MockEC2API) DeleteEgressOnlyInternetGatewayRequest(arg0 *ec2.DeleteEgressOnlyInternetGatewayInput) (*request.Request, *ec2.DeleteEgressOnlyInternetGatewayOutput) { 4675 m.ctrl.T.Helper() 4676 ret := m.ctrl.Call(m, "DeleteEgressOnlyInternetGatewayRequest", arg0) 4677 ret0, _ := ret[0].(*request.Request) 4678 ret1, _ := ret[1].(*ec2.DeleteEgressOnlyInternetGatewayOutput) 4679 return ret0, ret1 4680 } 4681 4682 // DeleteEgressOnlyInternetGatewayRequest indicates an expected call of DeleteEgressOnlyInternetGatewayRequest 4683 func (mr *MockEC2APIMockRecorder) DeleteEgressOnlyInternetGatewayRequest(arg0 interface{}) *gomock.Call { 4684 mr.mock.ctrl.T.Helper() 4685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteEgressOnlyInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteEgressOnlyInternetGatewayRequest), arg0) 4686 } 4687 4688 // DeleteFleets mocks base method 4689 func (m *MockEC2API) DeleteFleets(arg0 *ec2.DeleteFleetsInput) (*ec2.DeleteFleetsOutput, error) { 4690 m.ctrl.T.Helper() 4691 ret := m.ctrl.Call(m, "DeleteFleets", arg0) 4692 ret0, _ := ret[0].(*ec2.DeleteFleetsOutput) 4693 ret1, _ := ret[1].(error) 4694 return ret0, ret1 4695 } 4696 4697 // DeleteFleets indicates an expected call of DeleteFleets 4698 func (mr *MockEC2APIMockRecorder) DeleteFleets(arg0 interface{}) *gomock.Call { 4699 mr.mock.ctrl.T.Helper() 4700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleets", reflect.TypeOf((*MockEC2API)(nil).DeleteFleets), arg0) 4701 } 4702 4703 // DeleteFleetsWithContext mocks base method 4704 func (m *MockEC2API) DeleteFleetsWithContext(arg0 aws.Context, arg1 *ec2.DeleteFleetsInput, arg2 ...request.Option) (*ec2.DeleteFleetsOutput, error) { 4705 m.ctrl.T.Helper() 4706 varargs := []interface{}{arg0, arg1} 4707 for _, a := range arg2 { 4708 varargs = append(varargs, a) 4709 } 4710 ret := m.ctrl.Call(m, "DeleteFleetsWithContext", varargs...) 4711 ret0, _ := ret[0].(*ec2.DeleteFleetsOutput) 4712 ret1, _ := ret[1].(error) 4713 return ret0, ret1 4714 } 4715 4716 // DeleteFleetsWithContext indicates an expected call of DeleteFleetsWithContext 4717 func (mr *MockEC2APIMockRecorder) DeleteFleetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4718 mr.mock.ctrl.T.Helper() 4719 varargs := append([]interface{}{arg0, arg1}, arg2...) 4720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFleetsWithContext), varargs...) 4721 } 4722 4723 // DeleteFleetsRequest mocks base method 4724 func (m *MockEC2API) DeleteFleetsRequest(arg0 *ec2.DeleteFleetsInput) (*request.Request, *ec2.DeleteFleetsOutput) { 4725 m.ctrl.T.Helper() 4726 ret := m.ctrl.Call(m, "DeleteFleetsRequest", arg0) 4727 ret0, _ := ret[0].(*request.Request) 4728 ret1, _ := ret[1].(*ec2.DeleteFleetsOutput) 4729 return ret0, ret1 4730 } 4731 4732 // DeleteFleetsRequest indicates an expected call of DeleteFleetsRequest 4733 func (mr *MockEC2APIMockRecorder) DeleteFleetsRequest(arg0 interface{}) *gomock.Call { 4734 mr.mock.ctrl.T.Helper() 4735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFleetsRequest), arg0) 4736 } 4737 4738 // DeleteFlowLogs mocks base method 4739 func (m *MockEC2API) DeleteFlowLogs(arg0 *ec2.DeleteFlowLogsInput) (*ec2.DeleteFlowLogsOutput, error) { 4740 m.ctrl.T.Helper() 4741 ret := m.ctrl.Call(m, "DeleteFlowLogs", arg0) 4742 ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput) 4743 ret1, _ := ret[1].(error) 4744 return ret0, ret1 4745 } 4746 4747 // DeleteFlowLogs indicates an expected call of DeleteFlowLogs 4748 func (mr *MockEC2APIMockRecorder) DeleteFlowLogs(arg0 interface{}) *gomock.Call { 4749 mr.mock.ctrl.T.Helper() 4750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogs), arg0) 4751 } 4752 4753 // DeleteFlowLogsWithContext mocks base method 4754 func (m *MockEC2API) DeleteFlowLogsWithContext(arg0 aws.Context, arg1 *ec2.DeleteFlowLogsInput, arg2 ...request.Option) (*ec2.DeleteFlowLogsOutput, error) { 4755 m.ctrl.T.Helper() 4756 varargs := []interface{}{arg0, arg1} 4757 for _, a := range arg2 { 4758 varargs = append(varargs, a) 4759 } 4760 ret := m.ctrl.Call(m, "DeleteFlowLogsWithContext", varargs...) 4761 ret0, _ := ret[0].(*ec2.DeleteFlowLogsOutput) 4762 ret1, _ := ret[1].(error) 4763 return ret0, ret1 4764 } 4765 4766 // DeleteFlowLogsWithContext indicates an expected call of DeleteFlowLogsWithContext 4767 func (mr *MockEC2APIMockRecorder) DeleteFlowLogsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4768 mr.mock.ctrl.T.Helper() 4769 varargs := append([]interface{}{arg0, arg1}, arg2...) 4770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogsWithContext), varargs...) 4771 } 4772 4773 // DeleteFlowLogsRequest mocks base method 4774 func (m *MockEC2API) DeleteFlowLogsRequest(arg0 *ec2.DeleteFlowLogsInput) (*request.Request, *ec2.DeleteFlowLogsOutput) { 4775 m.ctrl.T.Helper() 4776 ret := m.ctrl.Call(m, "DeleteFlowLogsRequest", arg0) 4777 ret0, _ := ret[0].(*request.Request) 4778 ret1, _ := ret[1].(*ec2.DeleteFlowLogsOutput) 4779 return ret0, ret1 4780 } 4781 4782 // DeleteFlowLogsRequest indicates an expected call of DeleteFlowLogsRequest 4783 func (mr *MockEC2APIMockRecorder) DeleteFlowLogsRequest(arg0 interface{}) *gomock.Call { 4784 mr.mock.ctrl.T.Helper() 4785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFlowLogsRequest), arg0) 4786 } 4787 4788 // DeleteFpgaImage mocks base method 4789 func (m *MockEC2API) DeleteFpgaImage(arg0 *ec2.DeleteFpgaImageInput) (*ec2.DeleteFpgaImageOutput, error) { 4790 m.ctrl.T.Helper() 4791 ret := m.ctrl.Call(m, "DeleteFpgaImage", arg0) 4792 ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput) 4793 ret1, _ := ret[1].(error) 4794 return ret0, ret1 4795 } 4796 4797 // DeleteFpgaImage indicates an expected call of DeleteFpgaImage 4798 func (mr *MockEC2APIMockRecorder) DeleteFpgaImage(arg0 interface{}) *gomock.Call { 4799 mr.mock.ctrl.T.Helper() 4800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImage", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImage), arg0) 4801 } 4802 4803 // DeleteFpgaImageWithContext mocks base method 4804 func (m *MockEC2API) DeleteFpgaImageWithContext(arg0 aws.Context, arg1 *ec2.DeleteFpgaImageInput, arg2 ...request.Option) (*ec2.DeleteFpgaImageOutput, error) { 4805 m.ctrl.T.Helper() 4806 varargs := []interface{}{arg0, arg1} 4807 for _, a := range arg2 { 4808 varargs = append(varargs, a) 4809 } 4810 ret := m.ctrl.Call(m, "DeleteFpgaImageWithContext", varargs...) 4811 ret0, _ := ret[0].(*ec2.DeleteFpgaImageOutput) 4812 ret1, _ := ret[1].(error) 4813 return ret0, ret1 4814 } 4815 4816 // DeleteFpgaImageWithContext indicates an expected call of DeleteFpgaImageWithContext 4817 func (mr *MockEC2APIMockRecorder) DeleteFpgaImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4818 mr.mock.ctrl.T.Helper() 4819 varargs := append([]interface{}{arg0, arg1}, arg2...) 4820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImageWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImageWithContext), varargs...) 4821 } 4822 4823 // DeleteFpgaImageRequest mocks base method 4824 func (m *MockEC2API) DeleteFpgaImageRequest(arg0 *ec2.DeleteFpgaImageInput) (*request.Request, *ec2.DeleteFpgaImageOutput) { 4825 m.ctrl.T.Helper() 4826 ret := m.ctrl.Call(m, "DeleteFpgaImageRequest", arg0) 4827 ret0, _ := ret[0].(*request.Request) 4828 ret1, _ := ret[1].(*ec2.DeleteFpgaImageOutput) 4829 return ret0, ret1 4830 } 4831 4832 // DeleteFpgaImageRequest indicates an expected call of DeleteFpgaImageRequest 4833 func (mr *MockEC2APIMockRecorder) DeleteFpgaImageRequest(arg0 interface{}) *gomock.Call { 4834 mr.mock.ctrl.T.Helper() 4835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteFpgaImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteFpgaImageRequest), arg0) 4836 } 4837 4838 // DeleteInternetGateway mocks base method 4839 func (m *MockEC2API) DeleteInternetGateway(arg0 *ec2.DeleteInternetGatewayInput) (*ec2.DeleteInternetGatewayOutput, error) { 4840 m.ctrl.T.Helper() 4841 ret := m.ctrl.Call(m, "DeleteInternetGateway", arg0) 4842 ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput) 4843 ret1, _ := ret[1].(error) 4844 return ret0, ret1 4845 } 4846 4847 // DeleteInternetGateway indicates an expected call of DeleteInternetGateway 4848 func (mr *MockEC2APIMockRecorder) DeleteInternetGateway(arg0 interface{}) *gomock.Call { 4849 mr.mock.ctrl.T.Helper() 4850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGateway), arg0) 4851 } 4852 4853 // DeleteInternetGatewayWithContext mocks base method 4854 func (m *MockEC2API) DeleteInternetGatewayWithContext(arg0 aws.Context, arg1 *ec2.DeleteInternetGatewayInput, arg2 ...request.Option) (*ec2.DeleteInternetGatewayOutput, error) { 4855 m.ctrl.T.Helper() 4856 varargs := []interface{}{arg0, arg1} 4857 for _, a := range arg2 { 4858 varargs = append(varargs, a) 4859 } 4860 ret := m.ctrl.Call(m, "DeleteInternetGatewayWithContext", varargs...) 4861 ret0, _ := ret[0].(*ec2.DeleteInternetGatewayOutput) 4862 ret1, _ := ret[1].(error) 4863 return ret0, ret1 4864 } 4865 4866 // DeleteInternetGatewayWithContext indicates an expected call of DeleteInternetGatewayWithContext 4867 func (mr *MockEC2APIMockRecorder) DeleteInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4868 mr.mock.ctrl.T.Helper() 4869 varargs := append([]interface{}{arg0, arg1}, arg2...) 4870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGatewayWithContext), varargs...) 4871 } 4872 4873 // DeleteInternetGatewayRequest mocks base method 4874 func (m *MockEC2API) DeleteInternetGatewayRequest(arg0 *ec2.DeleteInternetGatewayInput) (*request.Request, *ec2.DeleteInternetGatewayOutput) { 4875 m.ctrl.T.Helper() 4876 ret := m.ctrl.Call(m, "DeleteInternetGatewayRequest", arg0) 4877 ret0, _ := ret[0].(*request.Request) 4878 ret1, _ := ret[1].(*ec2.DeleteInternetGatewayOutput) 4879 return ret0, ret1 4880 } 4881 4882 // DeleteInternetGatewayRequest indicates an expected call of DeleteInternetGatewayRequest 4883 func (mr *MockEC2APIMockRecorder) DeleteInternetGatewayRequest(arg0 interface{}) *gomock.Call { 4884 mr.mock.ctrl.T.Helper() 4885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteInternetGatewayRequest), arg0) 4886 } 4887 4888 // DeleteKeyPair mocks base method 4889 func (m *MockEC2API) DeleteKeyPair(arg0 *ec2.DeleteKeyPairInput) (*ec2.DeleteKeyPairOutput, error) { 4890 m.ctrl.T.Helper() 4891 ret := m.ctrl.Call(m, "DeleteKeyPair", arg0) 4892 ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput) 4893 ret1, _ := ret[1].(error) 4894 return ret0, ret1 4895 } 4896 4897 // DeleteKeyPair indicates an expected call of DeleteKeyPair 4898 func (mr *MockEC2APIMockRecorder) DeleteKeyPair(arg0 interface{}) *gomock.Call { 4899 mr.mock.ctrl.T.Helper() 4900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPair", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPair), arg0) 4901 } 4902 4903 // DeleteKeyPairWithContext mocks base method 4904 func (m *MockEC2API) DeleteKeyPairWithContext(arg0 aws.Context, arg1 *ec2.DeleteKeyPairInput, arg2 ...request.Option) (*ec2.DeleteKeyPairOutput, error) { 4905 m.ctrl.T.Helper() 4906 varargs := []interface{}{arg0, arg1} 4907 for _, a := range arg2 { 4908 varargs = append(varargs, a) 4909 } 4910 ret := m.ctrl.Call(m, "DeleteKeyPairWithContext", varargs...) 4911 ret0, _ := ret[0].(*ec2.DeleteKeyPairOutput) 4912 ret1, _ := ret[1].(error) 4913 return ret0, ret1 4914 } 4915 4916 // DeleteKeyPairWithContext indicates an expected call of DeleteKeyPairWithContext 4917 func (mr *MockEC2APIMockRecorder) DeleteKeyPairWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4918 mr.mock.ctrl.T.Helper() 4919 varargs := append([]interface{}{arg0, arg1}, arg2...) 4920 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPairWithContext), varargs...) 4921 } 4922 4923 // DeleteKeyPairRequest mocks base method 4924 func (m *MockEC2API) DeleteKeyPairRequest(arg0 *ec2.DeleteKeyPairInput) (*request.Request, *ec2.DeleteKeyPairOutput) { 4925 m.ctrl.T.Helper() 4926 ret := m.ctrl.Call(m, "DeleteKeyPairRequest", arg0) 4927 ret0, _ := ret[0].(*request.Request) 4928 ret1, _ := ret[1].(*ec2.DeleteKeyPairOutput) 4929 return ret0, ret1 4930 } 4931 4932 // DeleteKeyPairRequest indicates an expected call of DeleteKeyPairRequest 4933 func (mr *MockEC2APIMockRecorder) DeleteKeyPairRequest(arg0 interface{}) *gomock.Call { 4934 mr.mock.ctrl.T.Helper() 4935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteKeyPairRequest), arg0) 4936 } 4937 4938 // DeleteLaunchTemplate mocks base method 4939 func (m *MockEC2API) DeleteLaunchTemplate(arg0 *ec2.DeleteLaunchTemplateInput) (*ec2.DeleteLaunchTemplateOutput, error) { 4940 m.ctrl.T.Helper() 4941 ret := m.ctrl.Call(m, "DeleteLaunchTemplate", arg0) 4942 ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput) 4943 ret1, _ := ret[1].(error) 4944 return ret0, ret1 4945 } 4946 4947 // DeleteLaunchTemplate indicates an expected call of DeleteLaunchTemplate 4948 func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplate(arg0 interface{}) *gomock.Call { 4949 mr.mock.ctrl.T.Helper() 4950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplate), arg0) 4951 } 4952 4953 // DeleteLaunchTemplateWithContext mocks base method 4954 func (m *MockEC2API) DeleteLaunchTemplateWithContext(arg0 aws.Context, arg1 *ec2.DeleteLaunchTemplateInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateOutput, error) { 4955 m.ctrl.T.Helper() 4956 varargs := []interface{}{arg0, arg1} 4957 for _, a := range arg2 { 4958 varargs = append(varargs, a) 4959 } 4960 ret := m.ctrl.Call(m, "DeleteLaunchTemplateWithContext", varargs...) 4961 ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateOutput) 4962 ret1, _ := ret[1].(error) 4963 return ret0, ret1 4964 } 4965 4966 // DeleteLaunchTemplateWithContext indicates an expected call of DeleteLaunchTemplateWithContext 4967 func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 4968 mr.mock.ctrl.T.Helper() 4969 varargs := append([]interface{}{arg0, arg1}, arg2...) 4970 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateWithContext), varargs...) 4971 } 4972 4973 // DeleteLaunchTemplateRequest mocks base method 4974 func (m *MockEC2API) DeleteLaunchTemplateRequest(arg0 *ec2.DeleteLaunchTemplateInput) (*request.Request, *ec2.DeleteLaunchTemplateOutput) { 4975 m.ctrl.T.Helper() 4976 ret := m.ctrl.Call(m, "DeleteLaunchTemplateRequest", arg0) 4977 ret0, _ := ret[0].(*request.Request) 4978 ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateOutput) 4979 return ret0, ret1 4980 } 4981 4982 // DeleteLaunchTemplateRequest indicates an expected call of DeleteLaunchTemplateRequest 4983 func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateRequest(arg0 interface{}) *gomock.Call { 4984 mr.mock.ctrl.T.Helper() 4985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateRequest), arg0) 4986 } 4987 4988 // DeleteLaunchTemplateVersions mocks base method 4989 func (m *MockEC2API) DeleteLaunchTemplateVersions(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*ec2.DeleteLaunchTemplateVersionsOutput, error) { 4990 m.ctrl.T.Helper() 4991 ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersions", arg0) 4992 ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput) 4993 ret1, _ := ret[1].(error) 4994 return ret0, ret1 4995 } 4996 4997 // DeleteLaunchTemplateVersions indicates an expected call of DeleteLaunchTemplateVersions 4998 func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersions(arg0 interface{}) *gomock.Call { 4999 mr.mock.ctrl.T.Helper() 5000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersions), arg0) 5001 } 5002 5003 // DeleteLaunchTemplateVersionsWithContext mocks base method 5004 func (m *MockEC2API) DeleteLaunchTemplateVersionsWithContext(arg0 aws.Context, arg1 *ec2.DeleteLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DeleteLaunchTemplateVersionsOutput, error) { 5005 m.ctrl.T.Helper() 5006 varargs := []interface{}{arg0, arg1} 5007 for _, a := range arg2 { 5008 varargs = append(varargs, a) 5009 } 5010 ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsWithContext", varargs...) 5011 ret0, _ := ret[0].(*ec2.DeleteLaunchTemplateVersionsOutput) 5012 ret1, _ := ret[1].(error) 5013 return ret0, ret1 5014 } 5015 5016 // DeleteLaunchTemplateVersionsWithContext indicates an expected call of DeleteLaunchTemplateVersionsWithContext 5017 func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5018 mr.mock.ctrl.T.Helper() 5019 varargs := append([]interface{}{arg0, arg1}, arg2...) 5020 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersionsWithContext), varargs...) 5021 } 5022 5023 // DeleteLaunchTemplateVersionsRequest mocks base method 5024 func (m *MockEC2API) DeleteLaunchTemplateVersionsRequest(arg0 *ec2.DeleteLaunchTemplateVersionsInput) (*request.Request, *ec2.DeleteLaunchTemplateVersionsOutput) { 5025 m.ctrl.T.Helper() 5026 ret := m.ctrl.Call(m, "DeleteLaunchTemplateVersionsRequest", arg0) 5027 ret0, _ := ret[0].(*request.Request) 5028 ret1, _ := ret[1].(*ec2.DeleteLaunchTemplateVersionsOutput) 5029 return ret0, ret1 5030 } 5031 5032 // DeleteLaunchTemplateVersionsRequest indicates an expected call of DeleteLaunchTemplateVersionsRequest 5033 func (mr *MockEC2APIMockRecorder) DeleteLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call { 5034 mr.mock.ctrl.T.Helper() 5035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteLaunchTemplateVersionsRequest), arg0) 5036 } 5037 5038 // DeleteNatGateway mocks base method 5039 func (m *MockEC2API) DeleteNatGateway(arg0 *ec2.DeleteNatGatewayInput) (*ec2.DeleteNatGatewayOutput, error) { 5040 m.ctrl.T.Helper() 5041 ret := m.ctrl.Call(m, "DeleteNatGateway", arg0) 5042 ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput) 5043 ret1, _ := ret[1].(error) 5044 return ret0, ret1 5045 } 5046 5047 // DeleteNatGateway indicates an expected call of DeleteNatGateway 5048 func (mr *MockEC2APIMockRecorder) DeleteNatGateway(arg0 interface{}) *gomock.Call { 5049 mr.mock.ctrl.T.Helper() 5050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGateway), arg0) 5051 } 5052 5053 // DeleteNatGatewayWithContext mocks base method 5054 func (m *MockEC2API) DeleteNatGatewayWithContext(arg0 aws.Context, arg1 *ec2.DeleteNatGatewayInput, arg2 ...request.Option) (*ec2.DeleteNatGatewayOutput, error) { 5055 m.ctrl.T.Helper() 5056 varargs := []interface{}{arg0, arg1} 5057 for _, a := range arg2 { 5058 varargs = append(varargs, a) 5059 } 5060 ret := m.ctrl.Call(m, "DeleteNatGatewayWithContext", varargs...) 5061 ret0, _ := ret[0].(*ec2.DeleteNatGatewayOutput) 5062 ret1, _ := ret[1].(error) 5063 return ret0, ret1 5064 } 5065 5066 // DeleteNatGatewayWithContext indicates an expected call of DeleteNatGatewayWithContext 5067 func (mr *MockEC2APIMockRecorder) DeleteNatGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5068 mr.mock.ctrl.T.Helper() 5069 varargs := append([]interface{}{arg0, arg1}, arg2...) 5070 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGatewayWithContext), varargs...) 5071 } 5072 5073 // DeleteNatGatewayRequest mocks base method 5074 func (m *MockEC2API) DeleteNatGatewayRequest(arg0 *ec2.DeleteNatGatewayInput) (*request.Request, *ec2.DeleteNatGatewayOutput) { 5075 m.ctrl.T.Helper() 5076 ret := m.ctrl.Call(m, "DeleteNatGatewayRequest", arg0) 5077 ret0, _ := ret[0].(*request.Request) 5078 ret1, _ := ret[1].(*ec2.DeleteNatGatewayOutput) 5079 return ret0, ret1 5080 } 5081 5082 // DeleteNatGatewayRequest indicates an expected call of DeleteNatGatewayRequest 5083 func (mr *MockEC2APIMockRecorder) DeleteNatGatewayRequest(arg0 interface{}) *gomock.Call { 5084 mr.mock.ctrl.T.Helper() 5085 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNatGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNatGatewayRequest), arg0) 5086 } 5087 5088 // DeleteNetworkAcl mocks base method 5089 func (m *MockEC2API) DeleteNetworkAcl(arg0 *ec2.DeleteNetworkAclInput) (*ec2.DeleteNetworkAclOutput, error) { 5090 m.ctrl.T.Helper() 5091 ret := m.ctrl.Call(m, "DeleteNetworkAcl", arg0) 5092 ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput) 5093 ret1, _ := ret[1].(error) 5094 return ret0, ret1 5095 } 5096 5097 // DeleteNetworkAcl indicates an expected call of DeleteNetworkAcl 5098 func (mr *MockEC2APIMockRecorder) DeleteNetworkAcl(arg0 interface{}) *gomock.Call { 5099 mr.mock.ctrl.T.Helper() 5100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAcl", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAcl), arg0) 5101 } 5102 5103 // DeleteNetworkAclWithContext mocks base method 5104 func (m *MockEC2API) DeleteNetworkAclWithContext(arg0 aws.Context, arg1 *ec2.DeleteNetworkAclInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclOutput, error) { 5105 m.ctrl.T.Helper() 5106 varargs := []interface{}{arg0, arg1} 5107 for _, a := range arg2 { 5108 varargs = append(varargs, a) 5109 } 5110 ret := m.ctrl.Call(m, "DeleteNetworkAclWithContext", varargs...) 5111 ret0, _ := ret[0].(*ec2.DeleteNetworkAclOutput) 5112 ret1, _ := ret[1].(error) 5113 return ret0, ret1 5114 } 5115 5116 // DeleteNetworkAclWithContext indicates an expected call of DeleteNetworkAclWithContext 5117 func (mr *MockEC2APIMockRecorder) DeleteNetworkAclWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5118 mr.mock.ctrl.T.Helper() 5119 varargs := append([]interface{}{arg0, arg1}, arg2...) 5120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclWithContext), varargs...) 5121 } 5122 5123 // DeleteNetworkAclRequest mocks base method 5124 func (m *MockEC2API) DeleteNetworkAclRequest(arg0 *ec2.DeleteNetworkAclInput) (*request.Request, *ec2.DeleteNetworkAclOutput) { 5125 m.ctrl.T.Helper() 5126 ret := m.ctrl.Call(m, "DeleteNetworkAclRequest", arg0) 5127 ret0, _ := ret[0].(*request.Request) 5128 ret1, _ := ret[1].(*ec2.DeleteNetworkAclOutput) 5129 return ret0, ret1 5130 } 5131 5132 // DeleteNetworkAclRequest indicates an expected call of DeleteNetworkAclRequest 5133 func (mr *MockEC2APIMockRecorder) DeleteNetworkAclRequest(arg0 interface{}) *gomock.Call { 5134 mr.mock.ctrl.T.Helper() 5135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclRequest), arg0) 5136 } 5137 5138 // DeleteNetworkAclEntry mocks base method 5139 func (m *MockEC2API) DeleteNetworkAclEntry(arg0 *ec2.DeleteNetworkAclEntryInput) (*ec2.DeleteNetworkAclEntryOutput, error) { 5140 m.ctrl.T.Helper() 5141 ret := m.ctrl.Call(m, "DeleteNetworkAclEntry", arg0) 5142 ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput) 5143 ret1, _ := ret[1].(error) 5144 return ret0, ret1 5145 } 5146 5147 // DeleteNetworkAclEntry indicates an expected call of DeleteNetworkAclEntry 5148 func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntry(arg0 interface{}) *gomock.Call { 5149 mr.mock.ctrl.T.Helper() 5150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntry), arg0) 5151 } 5152 5153 // DeleteNetworkAclEntryWithContext mocks base method 5154 func (m *MockEC2API) DeleteNetworkAclEntryWithContext(arg0 aws.Context, arg1 *ec2.DeleteNetworkAclEntryInput, arg2 ...request.Option) (*ec2.DeleteNetworkAclEntryOutput, error) { 5155 m.ctrl.T.Helper() 5156 varargs := []interface{}{arg0, arg1} 5157 for _, a := range arg2 { 5158 varargs = append(varargs, a) 5159 } 5160 ret := m.ctrl.Call(m, "DeleteNetworkAclEntryWithContext", varargs...) 5161 ret0, _ := ret[0].(*ec2.DeleteNetworkAclEntryOutput) 5162 ret1, _ := ret[1].(error) 5163 return ret0, ret1 5164 } 5165 5166 // DeleteNetworkAclEntryWithContext indicates an expected call of DeleteNetworkAclEntryWithContext 5167 func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5168 mr.mock.ctrl.T.Helper() 5169 varargs := append([]interface{}{arg0, arg1}, arg2...) 5170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntryWithContext), varargs...) 5171 } 5172 5173 // DeleteNetworkAclEntryRequest mocks base method 5174 func (m *MockEC2API) DeleteNetworkAclEntryRequest(arg0 *ec2.DeleteNetworkAclEntryInput) (*request.Request, *ec2.DeleteNetworkAclEntryOutput) { 5175 m.ctrl.T.Helper() 5176 ret := m.ctrl.Call(m, "DeleteNetworkAclEntryRequest", arg0) 5177 ret0, _ := ret[0].(*request.Request) 5178 ret1, _ := ret[1].(*ec2.DeleteNetworkAclEntryOutput) 5179 return ret0, ret1 5180 } 5181 5182 // DeleteNetworkAclEntryRequest indicates an expected call of DeleteNetworkAclEntryRequest 5183 func (mr *MockEC2APIMockRecorder) DeleteNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { 5184 mr.mock.ctrl.T.Helper() 5185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkAclEntryRequest), arg0) 5186 } 5187 5188 // DeleteNetworkInterface mocks base method 5189 func (m *MockEC2API) DeleteNetworkInterface(arg0 *ec2.DeleteNetworkInterfaceInput) (*ec2.DeleteNetworkInterfaceOutput, error) { 5190 m.ctrl.T.Helper() 5191 ret := m.ctrl.Call(m, "DeleteNetworkInterface", arg0) 5192 ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput) 5193 ret1, _ := ret[1].(error) 5194 return ret0, ret1 5195 } 5196 5197 // DeleteNetworkInterface indicates an expected call of DeleteNetworkInterface 5198 func (mr *MockEC2APIMockRecorder) DeleteNetworkInterface(arg0 interface{}) *gomock.Call { 5199 mr.mock.ctrl.T.Helper() 5200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterface), arg0) 5201 } 5202 5203 // DeleteNetworkInterfaceWithContext mocks base method 5204 func (m *MockEC2API) DeleteNetworkInterfaceWithContext(arg0 aws.Context, arg1 *ec2.DeleteNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfaceOutput, error) { 5205 m.ctrl.T.Helper() 5206 varargs := []interface{}{arg0, arg1} 5207 for _, a := range arg2 { 5208 varargs = append(varargs, a) 5209 } 5210 ret := m.ctrl.Call(m, "DeleteNetworkInterfaceWithContext", varargs...) 5211 ret0, _ := ret[0].(*ec2.DeleteNetworkInterfaceOutput) 5212 ret1, _ := ret[1].(error) 5213 return ret0, ret1 5214 } 5215 5216 // DeleteNetworkInterfaceWithContext indicates an expected call of DeleteNetworkInterfaceWithContext 5217 func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfaceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5218 mr.mock.ctrl.T.Helper() 5219 varargs := append([]interface{}{arg0, arg1}, arg2...) 5220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfaceWithContext), varargs...) 5221 } 5222 5223 // DeleteNetworkInterfaceRequest mocks base method 5224 func (m *MockEC2API) DeleteNetworkInterfaceRequest(arg0 *ec2.DeleteNetworkInterfaceInput) (*request.Request, *ec2.DeleteNetworkInterfaceOutput) { 5225 m.ctrl.T.Helper() 5226 ret := m.ctrl.Call(m, "DeleteNetworkInterfaceRequest", arg0) 5227 ret0, _ := ret[0].(*request.Request) 5228 ret1, _ := ret[1].(*ec2.DeleteNetworkInterfaceOutput) 5229 return ret0, ret1 5230 } 5231 5232 // DeleteNetworkInterfaceRequest indicates an expected call of DeleteNetworkInterfaceRequest 5233 func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { 5234 mr.mock.ctrl.T.Helper() 5235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfaceRequest), arg0) 5236 } 5237 5238 // DeleteNetworkInterfacePermission mocks base method 5239 func (m *MockEC2API) DeleteNetworkInterfacePermission(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*ec2.DeleteNetworkInterfacePermissionOutput, error) { 5240 m.ctrl.T.Helper() 5241 ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermission", arg0) 5242 ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput) 5243 ret1, _ := ret[1].(error) 5244 return ret0, ret1 5245 } 5246 5247 // DeleteNetworkInterfacePermission indicates an expected call of DeleteNetworkInterfacePermission 5248 func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermission(arg0 interface{}) *gomock.Call { 5249 mr.mock.ctrl.T.Helper() 5250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermission", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermission), arg0) 5251 } 5252 5253 // DeleteNetworkInterfacePermissionWithContext mocks base method 5254 func (m *MockEC2API) DeleteNetworkInterfacePermissionWithContext(arg0 aws.Context, arg1 *ec2.DeleteNetworkInterfacePermissionInput, arg2 ...request.Option) (*ec2.DeleteNetworkInterfacePermissionOutput, error) { 5255 m.ctrl.T.Helper() 5256 varargs := []interface{}{arg0, arg1} 5257 for _, a := range arg2 { 5258 varargs = append(varargs, a) 5259 } 5260 ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionWithContext", varargs...) 5261 ret0, _ := ret[0].(*ec2.DeleteNetworkInterfacePermissionOutput) 5262 ret1, _ := ret[1].(error) 5263 return ret0, ret1 5264 } 5265 5266 // DeleteNetworkInterfacePermissionWithContext indicates an expected call of DeleteNetworkInterfacePermissionWithContext 5267 func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermissionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5268 mr.mock.ctrl.T.Helper() 5269 varargs := append([]interface{}{arg0, arg1}, arg2...) 5270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermissionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermissionWithContext), varargs...) 5271 } 5272 5273 // DeleteNetworkInterfacePermissionRequest mocks base method 5274 func (m *MockEC2API) DeleteNetworkInterfacePermissionRequest(arg0 *ec2.DeleteNetworkInterfacePermissionInput) (*request.Request, *ec2.DeleteNetworkInterfacePermissionOutput) { 5275 m.ctrl.T.Helper() 5276 ret := m.ctrl.Call(m, "DeleteNetworkInterfacePermissionRequest", arg0) 5277 ret0, _ := ret[0].(*request.Request) 5278 ret1, _ := ret[1].(*ec2.DeleteNetworkInterfacePermissionOutput) 5279 return ret0, ret1 5280 } 5281 5282 // DeleteNetworkInterfacePermissionRequest indicates an expected call of DeleteNetworkInterfacePermissionRequest 5283 func (mr *MockEC2APIMockRecorder) DeleteNetworkInterfacePermissionRequest(arg0 interface{}) *gomock.Call { 5284 mr.mock.ctrl.T.Helper() 5285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNetworkInterfacePermissionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteNetworkInterfacePermissionRequest), arg0) 5286 } 5287 5288 // DeletePlacementGroup mocks base method 5289 func (m *MockEC2API) DeletePlacementGroup(arg0 *ec2.DeletePlacementGroupInput) (*ec2.DeletePlacementGroupOutput, error) { 5290 m.ctrl.T.Helper() 5291 ret := m.ctrl.Call(m, "DeletePlacementGroup", arg0) 5292 ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput) 5293 ret1, _ := ret[1].(error) 5294 return ret0, ret1 5295 } 5296 5297 // DeletePlacementGroup indicates an expected call of DeletePlacementGroup 5298 func (mr *MockEC2APIMockRecorder) DeletePlacementGroup(arg0 interface{}) *gomock.Call { 5299 mr.mock.ctrl.T.Helper() 5300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroup", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroup), arg0) 5301 } 5302 5303 // DeletePlacementGroupWithContext mocks base method 5304 func (m *MockEC2API) DeletePlacementGroupWithContext(arg0 aws.Context, arg1 *ec2.DeletePlacementGroupInput, arg2 ...request.Option) (*ec2.DeletePlacementGroupOutput, error) { 5305 m.ctrl.T.Helper() 5306 varargs := []interface{}{arg0, arg1} 5307 for _, a := range arg2 { 5308 varargs = append(varargs, a) 5309 } 5310 ret := m.ctrl.Call(m, "DeletePlacementGroupWithContext", varargs...) 5311 ret0, _ := ret[0].(*ec2.DeletePlacementGroupOutput) 5312 ret1, _ := ret[1].(error) 5313 return ret0, ret1 5314 } 5315 5316 // DeletePlacementGroupWithContext indicates an expected call of DeletePlacementGroupWithContext 5317 func (mr *MockEC2APIMockRecorder) DeletePlacementGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5318 mr.mock.ctrl.T.Helper() 5319 varargs := append([]interface{}{arg0, arg1}, arg2...) 5320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroupWithContext), varargs...) 5321 } 5322 5323 // DeletePlacementGroupRequest mocks base method 5324 func (m *MockEC2API) DeletePlacementGroupRequest(arg0 *ec2.DeletePlacementGroupInput) (*request.Request, *ec2.DeletePlacementGroupOutput) { 5325 m.ctrl.T.Helper() 5326 ret := m.ctrl.Call(m, "DeletePlacementGroupRequest", arg0) 5327 ret0, _ := ret[0].(*request.Request) 5328 ret1, _ := ret[1].(*ec2.DeletePlacementGroupOutput) 5329 return ret0, ret1 5330 } 5331 5332 // DeletePlacementGroupRequest indicates an expected call of DeletePlacementGroupRequest 5333 func (mr *MockEC2APIMockRecorder) DeletePlacementGroupRequest(arg0 interface{}) *gomock.Call { 5334 mr.mock.ctrl.T.Helper() 5335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePlacementGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeletePlacementGroupRequest), arg0) 5336 } 5337 5338 // DeleteRoute mocks base method 5339 func (m *MockEC2API) DeleteRoute(arg0 *ec2.DeleteRouteInput) (*ec2.DeleteRouteOutput, error) { 5340 m.ctrl.T.Helper() 5341 ret := m.ctrl.Call(m, "DeleteRoute", arg0) 5342 ret0, _ := ret[0].(*ec2.DeleteRouteOutput) 5343 ret1, _ := ret[1].(error) 5344 return ret0, ret1 5345 } 5346 5347 // DeleteRoute indicates an expected call of DeleteRoute 5348 func (mr *MockEC2APIMockRecorder) DeleteRoute(arg0 interface{}) *gomock.Call { 5349 mr.mock.ctrl.T.Helper() 5350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteRoute), arg0) 5351 } 5352 5353 // DeleteRouteWithContext mocks base method 5354 func (m *MockEC2API) DeleteRouteWithContext(arg0 aws.Context, arg1 *ec2.DeleteRouteInput, arg2 ...request.Option) (*ec2.DeleteRouteOutput, error) { 5355 m.ctrl.T.Helper() 5356 varargs := []interface{}{arg0, arg1} 5357 for _, a := range arg2 { 5358 varargs = append(varargs, a) 5359 } 5360 ret := m.ctrl.Call(m, "DeleteRouteWithContext", varargs...) 5361 ret0, _ := ret[0].(*ec2.DeleteRouteOutput) 5362 ret1, _ := ret[1].(error) 5363 return ret0, ret1 5364 } 5365 5366 // DeleteRouteWithContext indicates an expected call of DeleteRouteWithContext 5367 func (mr *MockEC2APIMockRecorder) DeleteRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5368 mr.mock.ctrl.T.Helper() 5369 varargs := append([]interface{}{arg0, arg1}, arg2...) 5370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteWithContext), varargs...) 5371 } 5372 5373 // DeleteRouteRequest mocks base method 5374 func (m *MockEC2API) DeleteRouteRequest(arg0 *ec2.DeleteRouteInput) (*request.Request, *ec2.DeleteRouteOutput) { 5375 m.ctrl.T.Helper() 5376 ret := m.ctrl.Call(m, "DeleteRouteRequest", arg0) 5377 ret0, _ := ret[0].(*request.Request) 5378 ret1, _ := ret[1].(*ec2.DeleteRouteOutput) 5379 return ret0, ret1 5380 } 5381 5382 // DeleteRouteRequest indicates an expected call of DeleteRouteRequest 5383 func (mr *MockEC2APIMockRecorder) DeleteRouteRequest(arg0 interface{}) *gomock.Call { 5384 mr.mock.ctrl.T.Helper() 5385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteRequest), arg0) 5386 } 5387 5388 // DeleteRouteTable mocks base method 5389 func (m *MockEC2API) DeleteRouteTable(arg0 *ec2.DeleteRouteTableInput) (*ec2.DeleteRouteTableOutput, error) { 5390 m.ctrl.T.Helper() 5391 ret := m.ctrl.Call(m, "DeleteRouteTable", arg0) 5392 ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput) 5393 ret1, _ := ret[1].(error) 5394 return ret0, ret1 5395 } 5396 5397 // DeleteRouteTable indicates an expected call of DeleteRouteTable 5398 func (mr *MockEC2APIMockRecorder) DeleteRouteTable(arg0 interface{}) *gomock.Call { 5399 mr.mock.ctrl.T.Helper() 5400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTable), arg0) 5401 } 5402 5403 // DeleteRouteTableWithContext mocks base method 5404 func (m *MockEC2API) DeleteRouteTableWithContext(arg0 aws.Context, arg1 *ec2.DeleteRouteTableInput, arg2 ...request.Option) (*ec2.DeleteRouteTableOutput, error) { 5405 m.ctrl.T.Helper() 5406 varargs := []interface{}{arg0, arg1} 5407 for _, a := range arg2 { 5408 varargs = append(varargs, a) 5409 } 5410 ret := m.ctrl.Call(m, "DeleteRouteTableWithContext", varargs...) 5411 ret0, _ := ret[0].(*ec2.DeleteRouteTableOutput) 5412 ret1, _ := ret[1].(error) 5413 return ret0, ret1 5414 } 5415 5416 // DeleteRouteTableWithContext indicates an expected call of DeleteRouteTableWithContext 5417 func (mr *MockEC2APIMockRecorder) DeleteRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5418 mr.mock.ctrl.T.Helper() 5419 varargs := append([]interface{}{arg0, arg1}, arg2...) 5420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTableWithContext), varargs...) 5421 } 5422 5423 // DeleteRouteTableRequest mocks base method 5424 func (m *MockEC2API) DeleteRouteTableRequest(arg0 *ec2.DeleteRouteTableInput) (*request.Request, *ec2.DeleteRouteTableOutput) { 5425 m.ctrl.T.Helper() 5426 ret := m.ctrl.Call(m, "DeleteRouteTableRequest", arg0) 5427 ret0, _ := ret[0].(*request.Request) 5428 ret1, _ := ret[1].(*ec2.DeleteRouteTableOutput) 5429 return ret0, ret1 5430 } 5431 5432 // DeleteRouteTableRequest indicates an expected call of DeleteRouteTableRequest 5433 func (mr *MockEC2APIMockRecorder) DeleteRouteTableRequest(arg0 interface{}) *gomock.Call { 5434 mr.mock.ctrl.T.Helper() 5435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteRouteTableRequest), arg0) 5436 } 5437 5438 // DeleteSecurityGroup mocks base method 5439 func (m *MockEC2API) DeleteSecurityGroup(arg0 *ec2.DeleteSecurityGroupInput) (*ec2.DeleteSecurityGroupOutput, error) { 5440 m.ctrl.T.Helper() 5441 ret := m.ctrl.Call(m, "DeleteSecurityGroup", arg0) 5442 ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput) 5443 ret1, _ := ret[1].(error) 5444 return ret0, ret1 5445 } 5446 5447 // DeleteSecurityGroup indicates an expected call of DeleteSecurityGroup 5448 func (mr *MockEC2APIMockRecorder) DeleteSecurityGroup(arg0 interface{}) *gomock.Call { 5449 mr.mock.ctrl.T.Helper() 5450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroup", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroup), arg0) 5451 } 5452 5453 // DeleteSecurityGroupWithContext mocks base method 5454 func (m *MockEC2API) DeleteSecurityGroupWithContext(arg0 aws.Context, arg1 *ec2.DeleteSecurityGroupInput, arg2 ...request.Option) (*ec2.DeleteSecurityGroupOutput, error) { 5455 m.ctrl.T.Helper() 5456 varargs := []interface{}{arg0, arg1} 5457 for _, a := range arg2 { 5458 varargs = append(varargs, a) 5459 } 5460 ret := m.ctrl.Call(m, "DeleteSecurityGroupWithContext", varargs...) 5461 ret0, _ := ret[0].(*ec2.DeleteSecurityGroupOutput) 5462 ret1, _ := ret[1].(error) 5463 return ret0, ret1 5464 } 5465 5466 // DeleteSecurityGroupWithContext indicates an expected call of DeleteSecurityGroupWithContext 5467 func (mr *MockEC2APIMockRecorder) DeleteSecurityGroupWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5468 mr.mock.ctrl.T.Helper() 5469 varargs := append([]interface{}{arg0, arg1}, arg2...) 5470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroupWithContext), varargs...) 5471 } 5472 5473 // DeleteSecurityGroupRequest mocks base method 5474 func (m *MockEC2API) DeleteSecurityGroupRequest(arg0 *ec2.DeleteSecurityGroupInput) (*request.Request, *ec2.DeleteSecurityGroupOutput) { 5475 m.ctrl.T.Helper() 5476 ret := m.ctrl.Call(m, "DeleteSecurityGroupRequest", arg0) 5477 ret0, _ := ret[0].(*request.Request) 5478 ret1, _ := ret[1].(*ec2.DeleteSecurityGroupOutput) 5479 return ret0, ret1 5480 } 5481 5482 // DeleteSecurityGroupRequest indicates an expected call of DeleteSecurityGroupRequest 5483 func (mr *MockEC2APIMockRecorder) DeleteSecurityGroupRequest(arg0 interface{}) *gomock.Call { 5484 mr.mock.ctrl.T.Helper() 5485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSecurityGroupRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSecurityGroupRequest), arg0) 5486 } 5487 5488 // DeleteSnapshot mocks base method 5489 func (m *MockEC2API) DeleteSnapshot(arg0 *ec2.DeleteSnapshotInput) (*ec2.DeleteSnapshotOutput, error) { 5490 m.ctrl.T.Helper() 5491 ret := m.ctrl.Call(m, "DeleteSnapshot", arg0) 5492 ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput) 5493 ret1, _ := ret[1].(error) 5494 return ret0, ret1 5495 } 5496 5497 // DeleteSnapshot indicates an expected call of DeleteSnapshot 5498 func (mr *MockEC2APIMockRecorder) DeleteSnapshot(arg0 interface{}) *gomock.Call { 5499 mr.mock.ctrl.T.Helper() 5500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshot", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshot), arg0) 5501 } 5502 5503 // DeleteSnapshotWithContext mocks base method 5504 func (m *MockEC2API) DeleteSnapshotWithContext(arg0 aws.Context, arg1 *ec2.DeleteSnapshotInput, arg2 ...request.Option) (*ec2.DeleteSnapshotOutput, error) { 5505 m.ctrl.T.Helper() 5506 varargs := []interface{}{arg0, arg1} 5507 for _, a := range arg2 { 5508 varargs = append(varargs, a) 5509 } 5510 ret := m.ctrl.Call(m, "DeleteSnapshotWithContext", varargs...) 5511 ret0, _ := ret[0].(*ec2.DeleteSnapshotOutput) 5512 ret1, _ := ret[1].(error) 5513 return ret0, ret1 5514 } 5515 5516 // DeleteSnapshotWithContext indicates an expected call of DeleteSnapshotWithContext 5517 func (mr *MockEC2APIMockRecorder) DeleteSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5518 mr.mock.ctrl.T.Helper() 5519 varargs := append([]interface{}{arg0, arg1}, arg2...) 5520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshotWithContext), varargs...) 5521 } 5522 5523 // DeleteSnapshotRequest mocks base method 5524 func (m *MockEC2API) DeleteSnapshotRequest(arg0 *ec2.DeleteSnapshotInput) (*request.Request, *ec2.DeleteSnapshotOutput) { 5525 m.ctrl.T.Helper() 5526 ret := m.ctrl.Call(m, "DeleteSnapshotRequest", arg0) 5527 ret0, _ := ret[0].(*request.Request) 5528 ret1, _ := ret[1].(*ec2.DeleteSnapshotOutput) 5529 return ret0, ret1 5530 } 5531 5532 // DeleteSnapshotRequest indicates an expected call of DeleteSnapshotRequest 5533 func (mr *MockEC2APIMockRecorder) DeleteSnapshotRequest(arg0 interface{}) *gomock.Call { 5534 mr.mock.ctrl.T.Helper() 5535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSnapshotRequest), arg0) 5536 } 5537 5538 // DeleteSpotDatafeedSubscription mocks base method 5539 func (m *MockEC2API) DeleteSpotDatafeedSubscription(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) { 5540 m.ctrl.T.Helper() 5541 ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscription", arg0) 5542 ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput) 5543 ret1, _ := ret[1].(error) 5544 return ret0, ret1 5545 } 5546 5547 // DeleteSpotDatafeedSubscription indicates an expected call of DeleteSpotDatafeedSubscription 5548 func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { 5549 mr.mock.ctrl.T.Helper() 5550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscription), arg0) 5551 } 5552 5553 // DeleteSpotDatafeedSubscriptionWithContext mocks base method 5554 func (m *MockEC2API) DeleteSpotDatafeedSubscriptionWithContext(arg0 aws.Context, arg1 *ec2.DeleteSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DeleteSpotDatafeedSubscriptionOutput, error) { 5555 m.ctrl.T.Helper() 5556 varargs := []interface{}{arg0, arg1} 5557 for _, a := range arg2 { 5558 varargs = append(varargs, a) 5559 } 5560 ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionWithContext", varargs...) 5561 ret0, _ := ret[0].(*ec2.DeleteSpotDatafeedSubscriptionOutput) 5562 ret1, _ := ret[1].(error) 5563 return ret0, ret1 5564 } 5565 5566 // DeleteSpotDatafeedSubscriptionWithContext indicates an expected call of DeleteSpotDatafeedSubscriptionWithContext 5567 func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5568 mr.mock.ctrl.T.Helper() 5569 varargs := append([]interface{}{arg0, arg1}, arg2...) 5570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionWithContext), varargs...) 5571 } 5572 5573 // DeleteSpotDatafeedSubscriptionRequest mocks base method 5574 func (m *MockEC2API) DeleteSpotDatafeedSubscriptionRequest(arg0 *ec2.DeleteSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DeleteSpotDatafeedSubscriptionOutput) { 5575 m.ctrl.T.Helper() 5576 ret := m.ctrl.Call(m, "DeleteSpotDatafeedSubscriptionRequest", arg0) 5577 ret0, _ := ret[0].(*request.Request) 5578 ret1, _ := ret[1].(*ec2.DeleteSpotDatafeedSubscriptionOutput) 5579 return ret0, ret1 5580 } 5581 5582 // DeleteSpotDatafeedSubscriptionRequest indicates an expected call of DeleteSpotDatafeedSubscriptionRequest 5583 func (mr *MockEC2APIMockRecorder) DeleteSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { 5584 mr.mock.ctrl.T.Helper() 5585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSpotDatafeedSubscriptionRequest), arg0) 5586 } 5587 5588 // DeleteSubnet mocks base method 5589 func (m *MockEC2API) DeleteSubnet(arg0 *ec2.DeleteSubnetInput) (*ec2.DeleteSubnetOutput, error) { 5590 m.ctrl.T.Helper() 5591 ret := m.ctrl.Call(m, "DeleteSubnet", arg0) 5592 ret0, _ := ret[0].(*ec2.DeleteSubnetOutput) 5593 ret1, _ := ret[1].(error) 5594 return ret0, ret1 5595 } 5596 5597 // DeleteSubnet indicates an expected call of DeleteSubnet 5598 func (mr *MockEC2APIMockRecorder) DeleteSubnet(arg0 interface{}) *gomock.Call { 5599 mr.mock.ctrl.T.Helper() 5600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnet", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnet), arg0) 5601 } 5602 5603 // DeleteSubnetWithContext mocks base method 5604 func (m *MockEC2API) DeleteSubnetWithContext(arg0 aws.Context, arg1 *ec2.DeleteSubnetInput, arg2 ...request.Option) (*ec2.DeleteSubnetOutput, error) { 5605 m.ctrl.T.Helper() 5606 varargs := []interface{}{arg0, arg1} 5607 for _, a := range arg2 { 5608 varargs = append(varargs, a) 5609 } 5610 ret := m.ctrl.Call(m, "DeleteSubnetWithContext", varargs...) 5611 ret0, _ := ret[0].(*ec2.DeleteSubnetOutput) 5612 ret1, _ := ret[1].(error) 5613 return ret0, ret1 5614 } 5615 5616 // DeleteSubnetWithContext indicates an expected call of DeleteSubnetWithContext 5617 func (mr *MockEC2APIMockRecorder) DeleteSubnetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5618 mr.mock.ctrl.T.Helper() 5619 varargs := append([]interface{}{arg0, arg1}, arg2...) 5620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetWithContext), varargs...) 5621 } 5622 5623 // DeleteSubnetRequest mocks base method 5624 func (m *MockEC2API) DeleteSubnetRequest(arg0 *ec2.DeleteSubnetInput) (*request.Request, *ec2.DeleteSubnetOutput) { 5625 m.ctrl.T.Helper() 5626 ret := m.ctrl.Call(m, "DeleteSubnetRequest", arg0) 5627 ret0, _ := ret[0].(*request.Request) 5628 ret1, _ := ret[1].(*ec2.DeleteSubnetOutput) 5629 return ret0, ret1 5630 } 5631 5632 // DeleteSubnetRequest indicates an expected call of DeleteSubnetRequest 5633 func (mr *MockEC2APIMockRecorder) DeleteSubnetRequest(arg0 interface{}) *gomock.Call { 5634 mr.mock.ctrl.T.Helper() 5635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubnetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteSubnetRequest), arg0) 5636 } 5637 5638 // DeleteTags mocks base method 5639 func (m *MockEC2API) DeleteTags(arg0 *ec2.DeleteTagsInput) (*ec2.DeleteTagsOutput, error) { 5640 m.ctrl.T.Helper() 5641 ret := m.ctrl.Call(m, "DeleteTags", arg0) 5642 ret0, _ := ret[0].(*ec2.DeleteTagsOutput) 5643 ret1, _ := ret[1].(error) 5644 return ret0, ret1 5645 } 5646 5647 // DeleteTags indicates an expected call of DeleteTags 5648 func (mr *MockEC2APIMockRecorder) DeleteTags(arg0 interface{}) *gomock.Call { 5649 mr.mock.ctrl.T.Helper() 5650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTags", reflect.TypeOf((*MockEC2API)(nil).DeleteTags), arg0) 5651 } 5652 5653 // DeleteTagsWithContext mocks base method 5654 func (m *MockEC2API) DeleteTagsWithContext(arg0 aws.Context, arg1 *ec2.DeleteTagsInput, arg2 ...request.Option) (*ec2.DeleteTagsOutput, error) { 5655 m.ctrl.T.Helper() 5656 varargs := []interface{}{arg0, arg1} 5657 for _, a := range arg2 { 5658 varargs = append(varargs, a) 5659 } 5660 ret := m.ctrl.Call(m, "DeleteTagsWithContext", varargs...) 5661 ret0, _ := ret[0].(*ec2.DeleteTagsOutput) 5662 ret1, _ := ret[1].(error) 5663 return ret0, ret1 5664 } 5665 5666 // DeleteTagsWithContext indicates an expected call of DeleteTagsWithContext 5667 func (mr *MockEC2APIMockRecorder) DeleteTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5668 mr.mock.ctrl.T.Helper() 5669 varargs := append([]interface{}{arg0, arg1}, arg2...) 5670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTagsWithContext), varargs...) 5671 } 5672 5673 // DeleteTagsRequest mocks base method 5674 func (m *MockEC2API) DeleteTagsRequest(arg0 *ec2.DeleteTagsInput) (*request.Request, *ec2.DeleteTagsOutput) { 5675 m.ctrl.T.Helper() 5676 ret := m.ctrl.Call(m, "DeleteTagsRequest", arg0) 5677 ret0, _ := ret[0].(*request.Request) 5678 ret1, _ := ret[1].(*ec2.DeleteTagsOutput) 5679 return ret0, ret1 5680 } 5681 5682 // DeleteTagsRequest indicates an expected call of DeleteTagsRequest 5683 func (mr *MockEC2APIMockRecorder) DeleteTagsRequest(arg0 interface{}) *gomock.Call { 5684 mr.mock.ctrl.T.Helper() 5685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTagsRequest), arg0) 5686 } 5687 5688 // DeleteTrafficMirrorFilter mocks base method 5689 func (m *MockEC2API) DeleteTrafficMirrorFilter(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*ec2.DeleteTrafficMirrorFilterOutput, error) { 5690 m.ctrl.T.Helper() 5691 ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilter", arg0) 5692 ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput) 5693 ret1, _ := ret[1].(error) 5694 return ret0, ret1 5695 } 5696 5697 // DeleteTrafficMirrorFilter indicates an expected call of DeleteTrafficMirrorFilter 5698 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilter(arg0 interface{}) *gomock.Call { 5699 mr.mock.ctrl.T.Helper() 5700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilter", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilter), arg0) 5701 } 5702 5703 // DeleteTrafficMirrorFilterWithContext mocks base method 5704 func (m *MockEC2API) DeleteTrafficMirrorFilterWithContext(arg0 aws.Context, arg1 *ec2.DeleteTrafficMirrorFilterInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterOutput, error) { 5705 m.ctrl.T.Helper() 5706 varargs := []interface{}{arg0, arg1} 5707 for _, a := range arg2 { 5708 varargs = append(varargs, a) 5709 } 5710 ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterWithContext", varargs...) 5711 ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterOutput) 5712 ret1, _ := ret[1].(error) 5713 return ret0, ret1 5714 } 5715 5716 // DeleteTrafficMirrorFilterWithContext indicates an expected call of DeleteTrafficMirrorFilterWithContext 5717 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5718 mr.mock.ctrl.T.Helper() 5719 varargs := append([]interface{}{arg0, arg1}, arg2...) 5720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterWithContext), varargs...) 5721 } 5722 5723 // DeleteTrafficMirrorFilterRequest mocks base method 5724 func (m *MockEC2API) DeleteTrafficMirrorFilterRequest(arg0 *ec2.DeleteTrafficMirrorFilterInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterOutput) { 5725 m.ctrl.T.Helper() 5726 ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRequest", arg0) 5727 ret0, _ := ret[0].(*request.Request) 5728 ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterOutput) 5729 return ret0, ret1 5730 } 5731 5732 // DeleteTrafficMirrorFilterRequest indicates an expected call of DeleteTrafficMirrorFilterRequest 5733 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRequest(arg0 interface{}) *gomock.Call { 5734 mr.mock.ctrl.T.Helper() 5735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRequest), arg0) 5736 } 5737 5738 // DeleteTrafficMirrorFilterRule mocks base method 5739 func (m *MockEC2API) DeleteTrafficMirrorFilterRule(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) { 5740 m.ctrl.T.Helper() 5741 ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRule", arg0) 5742 ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput) 5743 ret1, _ := ret[1].(error) 5744 return ret0, ret1 5745 } 5746 5747 // DeleteTrafficMirrorFilterRule indicates an expected call of DeleteTrafficMirrorFilterRule 5748 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { 5749 mr.mock.ctrl.T.Helper() 5750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRule), arg0) 5751 } 5752 5753 // DeleteTrafficMirrorFilterRuleWithContext mocks base method 5754 func (m *MockEC2API) DeleteTrafficMirrorFilterRuleWithContext(arg0 aws.Context, arg1 *ec2.DeleteTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorFilterRuleOutput, error) { 5755 m.ctrl.T.Helper() 5756 varargs := []interface{}{arg0, arg1} 5757 for _, a := range arg2 { 5758 varargs = append(varargs, a) 5759 } 5760 ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleWithContext", varargs...) 5761 ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorFilterRuleOutput) 5762 ret1, _ := ret[1].(error) 5763 return ret0, ret1 5764 } 5765 5766 // DeleteTrafficMirrorFilterRuleWithContext indicates an expected call of DeleteTrafficMirrorFilterRuleWithContext 5767 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5768 mr.mock.ctrl.T.Helper() 5769 varargs := append([]interface{}{arg0, arg1}, arg2...) 5770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleWithContext), varargs...) 5771 } 5772 5773 // DeleteTrafficMirrorFilterRuleRequest mocks base method 5774 func (m *MockEC2API) DeleteTrafficMirrorFilterRuleRequest(arg0 *ec2.DeleteTrafficMirrorFilterRuleInput) (*request.Request, *ec2.DeleteTrafficMirrorFilterRuleOutput) { 5775 m.ctrl.T.Helper() 5776 ret := m.ctrl.Call(m, "DeleteTrafficMirrorFilterRuleRequest", arg0) 5777 ret0, _ := ret[0].(*request.Request) 5778 ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorFilterRuleOutput) 5779 return ret0, ret1 5780 } 5781 5782 // DeleteTrafficMirrorFilterRuleRequest indicates an expected call of DeleteTrafficMirrorFilterRuleRequest 5783 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { 5784 mr.mock.ctrl.T.Helper() 5785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorFilterRuleRequest), arg0) 5786 } 5787 5788 // DeleteTrafficMirrorSession mocks base method 5789 func (m *MockEC2API) DeleteTrafficMirrorSession(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*ec2.DeleteTrafficMirrorSessionOutput, error) { 5790 m.ctrl.T.Helper() 5791 ret := m.ctrl.Call(m, "DeleteTrafficMirrorSession", arg0) 5792 ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput) 5793 ret1, _ := ret[1].(error) 5794 return ret0, ret1 5795 } 5796 5797 // DeleteTrafficMirrorSession indicates an expected call of DeleteTrafficMirrorSession 5798 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSession(arg0 interface{}) *gomock.Call { 5799 mr.mock.ctrl.T.Helper() 5800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSession), arg0) 5801 } 5802 5803 // DeleteTrafficMirrorSessionWithContext mocks base method 5804 func (m *MockEC2API) DeleteTrafficMirrorSessionWithContext(arg0 aws.Context, arg1 *ec2.DeleteTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorSessionOutput, error) { 5805 m.ctrl.T.Helper() 5806 varargs := []interface{}{arg0, arg1} 5807 for _, a := range arg2 { 5808 varargs = append(varargs, a) 5809 } 5810 ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionWithContext", varargs...) 5811 ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorSessionOutput) 5812 ret1, _ := ret[1].(error) 5813 return ret0, ret1 5814 } 5815 5816 // DeleteTrafficMirrorSessionWithContext indicates an expected call of DeleteTrafficMirrorSessionWithContext 5817 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5818 mr.mock.ctrl.T.Helper() 5819 varargs := append([]interface{}{arg0, arg1}, arg2...) 5820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSessionWithContext), varargs...) 5821 } 5822 5823 // DeleteTrafficMirrorSessionRequest mocks base method 5824 func (m *MockEC2API) DeleteTrafficMirrorSessionRequest(arg0 *ec2.DeleteTrafficMirrorSessionInput) (*request.Request, *ec2.DeleteTrafficMirrorSessionOutput) { 5825 m.ctrl.T.Helper() 5826 ret := m.ctrl.Call(m, "DeleteTrafficMirrorSessionRequest", arg0) 5827 ret0, _ := ret[0].(*request.Request) 5828 ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorSessionOutput) 5829 return ret0, ret1 5830 } 5831 5832 // DeleteTrafficMirrorSessionRequest indicates an expected call of DeleteTrafficMirrorSessionRequest 5833 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { 5834 mr.mock.ctrl.T.Helper() 5835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorSessionRequest), arg0) 5836 } 5837 5838 // DeleteTrafficMirrorTarget mocks base method 5839 func (m *MockEC2API) DeleteTrafficMirrorTarget(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*ec2.DeleteTrafficMirrorTargetOutput, error) { 5840 m.ctrl.T.Helper() 5841 ret := m.ctrl.Call(m, "DeleteTrafficMirrorTarget", arg0) 5842 ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput) 5843 ret1, _ := ret[1].(error) 5844 return ret0, ret1 5845 } 5846 5847 // DeleteTrafficMirrorTarget indicates an expected call of DeleteTrafficMirrorTarget 5848 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTarget(arg0 interface{}) *gomock.Call { 5849 mr.mock.ctrl.T.Helper() 5850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTarget", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTarget), arg0) 5851 } 5852 5853 // DeleteTrafficMirrorTargetWithContext mocks base method 5854 func (m *MockEC2API) DeleteTrafficMirrorTargetWithContext(arg0 aws.Context, arg1 *ec2.DeleteTrafficMirrorTargetInput, arg2 ...request.Option) (*ec2.DeleteTrafficMirrorTargetOutput, error) { 5855 m.ctrl.T.Helper() 5856 varargs := []interface{}{arg0, arg1} 5857 for _, a := range arg2 { 5858 varargs = append(varargs, a) 5859 } 5860 ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetWithContext", varargs...) 5861 ret0, _ := ret[0].(*ec2.DeleteTrafficMirrorTargetOutput) 5862 ret1, _ := ret[1].(error) 5863 return ret0, ret1 5864 } 5865 5866 // DeleteTrafficMirrorTargetWithContext indicates an expected call of DeleteTrafficMirrorTargetWithContext 5867 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTargetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5868 mr.mock.ctrl.T.Helper() 5869 varargs := append([]interface{}{arg0, arg1}, arg2...) 5870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTargetWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTargetWithContext), varargs...) 5871 } 5872 5873 // DeleteTrafficMirrorTargetRequest mocks base method 5874 func (m *MockEC2API) DeleteTrafficMirrorTargetRequest(arg0 *ec2.DeleteTrafficMirrorTargetInput) (*request.Request, *ec2.DeleteTrafficMirrorTargetOutput) { 5875 m.ctrl.T.Helper() 5876 ret := m.ctrl.Call(m, "DeleteTrafficMirrorTargetRequest", arg0) 5877 ret0, _ := ret[0].(*request.Request) 5878 ret1, _ := ret[1].(*ec2.DeleteTrafficMirrorTargetOutput) 5879 return ret0, ret1 5880 } 5881 5882 // DeleteTrafficMirrorTargetRequest indicates an expected call of DeleteTrafficMirrorTargetRequest 5883 func (mr *MockEC2APIMockRecorder) DeleteTrafficMirrorTargetRequest(arg0 interface{}) *gomock.Call { 5884 mr.mock.ctrl.T.Helper() 5885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTrafficMirrorTargetRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTrafficMirrorTargetRequest), arg0) 5886 } 5887 5888 // DeleteTransitGateway mocks base method 5889 func (m *MockEC2API) DeleteTransitGateway(arg0 *ec2.DeleteTransitGatewayInput) (*ec2.DeleteTransitGatewayOutput, error) { 5890 m.ctrl.T.Helper() 5891 ret := m.ctrl.Call(m, "DeleteTransitGateway", arg0) 5892 ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput) 5893 ret1, _ := ret[1].(error) 5894 return ret0, ret1 5895 } 5896 5897 // DeleteTransitGateway indicates an expected call of DeleteTransitGateway 5898 func (mr *MockEC2APIMockRecorder) DeleteTransitGateway(arg0 interface{}) *gomock.Call { 5899 mr.mock.ctrl.T.Helper() 5900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGateway), arg0) 5901 } 5902 5903 // DeleteTransitGatewayWithContext mocks base method 5904 func (m *MockEC2API) DeleteTransitGatewayWithContext(arg0 aws.Context, arg1 *ec2.DeleteTransitGatewayInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayOutput, error) { 5905 m.ctrl.T.Helper() 5906 varargs := []interface{}{arg0, arg1} 5907 for _, a := range arg2 { 5908 varargs = append(varargs, a) 5909 } 5910 ret := m.ctrl.Call(m, "DeleteTransitGatewayWithContext", varargs...) 5911 ret0, _ := ret[0].(*ec2.DeleteTransitGatewayOutput) 5912 ret1, _ := ret[1].(error) 5913 return ret0, ret1 5914 } 5915 5916 // DeleteTransitGatewayWithContext indicates an expected call of DeleteTransitGatewayWithContext 5917 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5918 mr.mock.ctrl.T.Helper() 5919 varargs := append([]interface{}{arg0, arg1}, arg2...) 5920 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayWithContext), varargs...) 5921 } 5922 5923 // DeleteTransitGatewayRequest mocks base method 5924 func (m *MockEC2API) DeleteTransitGatewayRequest(arg0 *ec2.DeleteTransitGatewayInput) (*request.Request, *ec2.DeleteTransitGatewayOutput) { 5925 m.ctrl.T.Helper() 5926 ret := m.ctrl.Call(m, "DeleteTransitGatewayRequest", arg0) 5927 ret0, _ := ret[0].(*request.Request) 5928 ret1, _ := ret[1].(*ec2.DeleteTransitGatewayOutput) 5929 return ret0, ret1 5930 } 5931 5932 // DeleteTransitGatewayRequest indicates an expected call of DeleteTransitGatewayRequest 5933 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRequest(arg0 interface{}) *gomock.Call { 5934 mr.mock.ctrl.T.Helper() 5935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRequest), arg0) 5936 } 5937 5938 // DeleteTransitGatewayRoute mocks base method 5939 func (m *MockEC2API) DeleteTransitGatewayRoute(arg0 *ec2.DeleteTransitGatewayRouteInput) (*ec2.DeleteTransitGatewayRouteOutput, error) { 5940 m.ctrl.T.Helper() 5941 ret := m.ctrl.Call(m, "DeleteTransitGatewayRoute", arg0) 5942 ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput) 5943 ret1, _ := ret[1].(error) 5944 return ret0, ret1 5945 } 5946 5947 // DeleteTransitGatewayRoute indicates an expected call of DeleteTransitGatewayRoute 5948 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRoute(arg0 interface{}) *gomock.Call { 5949 mr.mock.ctrl.T.Helper() 5950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRoute), arg0) 5951 } 5952 5953 // DeleteTransitGatewayRouteWithContext mocks base method 5954 func (m *MockEC2API) DeleteTransitGatewayRouteWithContext(arg0 aws.Context, arg1 *ec2.DeleteTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteOutput, error) { 5955 m.ctrl.T.Helper() 5956 varargs := []interface{}{arg0, arg1} 5957 for _, a := range arg2 { 5958 varargs = append(varargs, a) 5959 } 5960 ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteWithContext", varargs...) 5961 ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteOutput) 5962 ret1, _ := ret[1].(error) 5963 return ret0, ret1 5964 } 5965 5966 // DeleteTransitGatewayRouteWithContext indicates an expected call of DeleteTransitGatewayRouteWithContext 5967 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 5968 mr.mock.ctrl.T.Helper() 5969 varargs := append([]interface{}{arg0, arg1}, arg2...) 5970 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteWithContext), varargs...) 5971 } 5972 5973 // DeleteTransitGatewayRouteRequest mocks base method 5974 func (m *MockEC2API) DeleteTransitGatewayRouteRequest(arg0 *ec2.DeleteTransitGatewayRouteInput) (*request.Request, *ec2.DeleteTransitGatewayRouteOutput) { 5975 m.ctrl.T.Helper() 5976 ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteRequest", arg0) 5977 ret0, _ := ret[0].(*request.Request) 5978 ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteOutput) 5979 return ret0, ret1 5980 } 5981 5982 // DeleteTransitGatewayRouteRequest indicates an expected call of DeleteTransitGatewayRouteRequest 5983 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { 5984 mr.mock.ctrl.T.Helper() 5985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteRequest), arg0) 5986 } 5987 5988 // DeleteTransitGatewayRouteTable mocks base method 5989 func (m *MockEC2API) DeleteTransitGatewayRouteTable(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*ec2.DeleteTransitGatewayRouteTableOutput, error) { 5990 m.ctrl.T.Helper() 5991 ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTable", arg0) 5992 ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput) 5993 ret1, _ := ret[1].(error) 5994 return ret0, ret1 5995 } 5996 5997 // DeleteTransitGatewayRouteTable indicates an expected call of DeleteTransitGatewayRouteTable 5998 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { 5999 mr.mock.ctrl.T.Helper() 6000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTable), arg0) 6001 } 6002 6003 // DeleteTransitGatewayRouteTableWithContext mocks base method 6004 func (m *MockEC2API) DeleteTransitGatewayRouteTableWithContext(arg0 aws.Context, arg1 *ec2.DeleteTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayRouteTableOutput, error) { 6005 m.ctrl.T.Helper() 6006 varargs := []interface{}{arg0, arg1} 6007 for _, a := range arg2 { 6008 varargs = append(varargs, a) 6009 } 6010 ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableWithContext", varargs...) 6011 ret0, _ := ret[0].(*ec2.DeleteTransitGatewayRouteTableOutput) 6012 ret1, _ := ret[1].(error) 6013 return ret0, ret1 6014 } 6015 6016 // DeleteTransitGatewayRouteTableWithContext indicates an expected call of DeleteTransitGatewayRouteTableWithContext 6017 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6018 mr.mock.ctrl.T.Helper() 6019 varargs := append([]interface{}{arg0, arg1}, arg2...) 6020 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableWithContext), varargs...) 6021 } 6022 6023 // DeleteTransitGatewayRouteTableRequest mocks base method 6024 func (m *MockEC2API) DeleteTransitGatewayRouteTableRequest(arg0 *ec2.DeleteTransitGatewayRouteTableInput) (*request.Request, *ec2.DeleteTransitGatewayRouteTableOutput) { 6025 m.ctrl.T.Helper() 6026 ret := m.ctrl.Call(m, "DeleteTransitGatewayRouteTableRequest", arg0) 6027 ret0, _ := ret[0].(*request.Request) 6028 ret1, _ := ret[1].(*ec2.DeleteTransitGatewayRouteTableOutput) 6029 return ret0, ret1 6030 } 6031 6032 // DeleteTransitGatewayRouteTableRequest indicates an expected call of DeleteTransitGatewayRouteTableRequest 6033 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { 6034 mr.mock.ctrl.T.Helper() 6035 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayRouteTableRequest), arg0) 6036 } 6037 6038 // DeleteTransitGatewayVpcAttachment mocks base method 6039 func (m *MockEC2API) DeleteTransitGatewayVpcAttachment(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) { 6040 m.ctrl.T.Helper() 6041 ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachment", arg0) 6042 ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) 6043 ret1, _ := ret[1].(error) 6044 return ret0, ret1 6045 } 6046 6047 // DeleteTransitGatewayVpcAttachment indicates an expected call of DeleteTransitGatewayVpcAttachment 6048 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { 6049 mr.mock.ctrl.T.Helper() 6050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachment), arg0) 6051 } 6052 6053 // DeleteTransitGatewayVpcAttachmentWithContext mocks base method 6054 func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentWithContext(arg0 aws.Context, arg1 *ec2.DeleteTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.DeleteTransitGatewayVpcAttachmentOutput, error) { 6055 m.ctrl.T.Helper() 6056 varargs := []interface{}{arg0, arg1} 6057 for _, a := range arg2 { 6058 varargs = append(varargs, a) 6059 } 6060 ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentWithContext", varargs...) 6061 ret0, _ := ret[0].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) 6062 ret1, _ := ret[1].(error) 6063 return ret0, ret1 6064 } 6065 6066 // DeleteTransitGatewayVpcAttachmentWithContext indicates an expected call of DeleteTransitGatewayVpcAttachmentWithContext 6067 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6068 mr.mock.ctrl.T.Helper() 6069 varargs := append([]interface{}{arg0, arg1}, arg2...) 6070 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentWithContext), varargs...) 6071 } 6072 6073 // DeleteTransitGatewayVpcAttachmentRequest mocks base method 6074 func (m *MockEC2API) DeleteTransitGatewayVpcAttachmentRequest(arg0 *ec2.DeleteTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.DeleteTransitGatewayVpcAttachmentOutput) { 6075 m.ctrl.T.Helper() 6076 ret := m.ctrl.Call(m, "DeleteTransitGatewayVpcAttachmentRequest", arg0) 6077 ret0, _ := ret[0].(*request.Request) 6078 ret1, _ := ret[1].(*ec2.DeleteTransitGatewayVpcAttachmentOutput) 6079 return ret0, ret1 6080 } 6081 6082 // DeleteTransitGatewayVpcAttachmentRequest indicates an expected call of DeleteTransitGatewayVpcAttachmentRequest 6083 func (mr *MockEC2APIMockRecorder) DeleteTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { 6084 mr.mock.ctrl.T.Helper() 6085 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteTransitGatewayVpcAttachmentRequest), arg0) 6086 } 6087 6088 // DeleteVolume mocks base method 6089 func (m *MockEC2API) DeleteVolume(arg0 *ec2.DeleteVolumeInput) (*ec2.DeleteVolumeOutput, error) { 6090 m.ctrl.T.Helper() 6091 ret := m.ctrl.Call(m, "DeleteVolume", arg0) 6092 ret0, _ := ret[0].(*ec2.DeleteVolumeOutput) 6093 ret1, _ := ret[1].(error) 6094 return ret0, ret1 6095 } 6096 6097 // DeleteVolume indicates an expected call of DeleteVolume 6098 func (mr *MockEC2APIMockRecorder) DeleteVolume(arg0 interface{}) *gomock.Call { 6099 mr.mock.ctrl.T.Helper() 6100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolume", reflect.TypeOf((*MockEC2API)(nil).DeleteVolume), arg0) 6101 } 6102 6103 // DeleteVolumeWithContext mocks base method 6104 func (m *MockEC2API) DeleteVolumeWithContext(arg0 aws.Context, arg1 *ec2.DeleteVolumeInput, arg2 ...request.Option) (*ec2.DeleteVolumeOutput, error) { 6105 m.ctrl.T.Helper() 6106 varargs := []interface{}{arg0, arg1} 6107 for _, a := range arg2 { 6108 varargs = append(varargs, a) 6109 } 6110 ret := m.ctrl.Call(m, "DeleteVolumeWithContext", varargs...) 6111 ret0, _ := ret[0].(*ec2.DeleteVolumeOutput) 6112 ret1, _ := ret[1].(error) 6113 return ret0, ret1 6114 } 6115 6116 // DeleteVolumeWithContext indicates an expected call of DeleteVolumeWithContext 6117 func (mr *MockEC2APIMockRecorder) DeleteVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6118 mr.mock.ctrl.T.Helper() 6119 varargs := append([]interface{}{arg0, arg1}, arg2...) 6120 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVolumeWithContext), varargs...) 6121 } 6122 6123 // DeleteVolumeRequest mocks base method 6124 func (m *MockEC2API) DeleteVolumeRequest(arg0 *ec2.DeleteVolumeInput) (*request.Request, *ec2.DeleteVolumeOutput) { 6125 m.ctrl.T.Helper() 6126 ret := m.ctrl.Call(m, "DeleteVolumeRequest", arg0) 6127 ret0, _ := ret[0].(*request.Request) 6128 ret1, _ := ret[1].(*ec2.DeleteVolumeOutput) 6129 return ret0, ret1 6130 } 6131 6132 // DeleteVolumeRequest indicates an expected call of DeleteVolumeRequest 6133 func (mr *MockEC2APIMockRecorder) DeleteVolumeRequest(arg0 interface{}) *gomock.Call { 6134 mr.mock.ctrl.T.Helper() 6135 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVolumeRequest), arg0) 6136 } 6137 6138 // DeleteVpc mocks base method 6139 func (m *MockEC2API) DeleteVpc(arg0 *ec2.DeleteVpcInput) (*ec2.DeleteVpcOutput, error) { 6140 m.ctrl.T.Helper() 6141 ret := m.ctrl.Call(m, "DeleteVpc", arg0) 6142 ret0, _ := ret[0].(*ec2.DeleteVpcOutput) 6143 ret1, _ := ret[1].(error) 6144 return ret0, ret1 6145 } 6146 6147 // DeleteVpc indicates an expected call of DeleteVpc 6148 func (mr *MockEC2APIMockRecorder) DeleteVpc(arg0 interface{}) *gomock.Call { 6149 mr.mock.ctrl.T.Helper() 6150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpc", reflect.TypeOf((*MockEC2API)(nil).DeleteVpc), arg0) 6151 } 6152 6153 // DeleteVpcWithContext mocks base method 6154 func (m *MockEC2API) DeleteVpcWithContext(arg0 aws.Context, arg1 *ec2.DeleteVpcInput, arg2 ...request.Option) (*ec2.DeleteVpcOutput, error) { 6155 m.ctrl.T.Helper() 6156 varargs := []interface{}{arg0, arg1} 6157 for _, a := range arg2 { 6158 varargs = append(varargs, a) 6159 } 6160 ret := m.ctrl.Call(m, "DeleteVpcWithContext", varargs...) 6161 ret0, _ := ret[0].(*ec2.DeleteVpcOutput) 6162 ret1, _ := ret[1].(error) 6163 return ret0, ret1 6164 } 6165 6166 // DeleteVpcWithContext indicates an expected call of DeleteVpcWithContext 6167 func (mr *MockEC2APIMockRecorder) DeleteVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6168 mr.mock.ctrl.T.Helper() 6169 varargs := append([]interface{}{arg0, arg1}, arg2...) 6170 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcWithContext), varargs...) 6171 } 6172 6173 // DeleteVpcRequest mocks base method 6174 func (m *MockEC2API) DeleteVpcRequest(arg0 *ec2.DeleteVpcInput) (*request.Request, *ec2.DeleteVpcOutput) { 6175 m.ctrl.T.Helper() 6176 ret := m.ctrl.Call(m, "DeleteVpcRequest", arg0) 6177 ret0, _ := ret[0].(*request.Request) 6178 ret1, _ := ret[1].(*ec2.DeleteVpcOutput) 6179 return ret0, ret1 6180 } 6181 6182 // DeleteVpcRequest indicates an expected call of DeleteVpcRequest 6183 func (mr *MockEC2APIMockRecorder) DeleteVpcRequest(arg0 interface{}) *gomock.Call { 6184 mr.mock.ctrl.T.Helper() 6185 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcRequest), arg0) 6186 } 6187 6188 // DeleteVpcEndpointConnectionNotifications mocks base method 6189 func (m *MockEC2API) DeleteVpcEndpointConnectionNotifications(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) { 6190 m.ctrl.T.Helper() 6191 ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotifications", arg0) 6192 ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) 6193 ret1, _ := ret[1].(error) 6194 return ret0, ret1 6195 } 6196 6197 // DeleteVpcEndpointConnectionNotifications indicates an expected call of DeleteVpcEndpointConnectionNotifications 6198 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call { 6199 mr.mock.ctrl.T.Helper() 6200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotifications), arg0) 6201 } 6202 6203 // DeleteVpcEndpointConnectionNotificationsWithContext mocks base method 6204 func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsWithContext(arg0 aws.Context, arg1 *ec2.DeleteVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointConnectionNotificationsOutput, error) { 6205 m.ctrl.T.Helper() 6206 varargs := []interface{}{arg0, arg1} 6207 for _, a := range arg2 { 6208 varargs = append(varargs, a) 6209 } 6210 ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsWithContext", varargs...) 6211 ret0, _ := ret[0].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) 6212 ret1, _ := ret[1].(error) 6213 return ret0, ret1 6214 } 6215 6216 // DeleteVpcEndpointConnectionNotificationsWithContext indicates an expected call of DeleteVpcEndpointConnectionNotificationsWithContext 6217 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6218 mr.mock.ctrl.T.Helper() 6219 varargs := append([]interface{}{arg0, arg1}, arg2...) 6220 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsWithContext), varargs...) 6221 } 6222 6223 // DeleteVpcEndpointConnectionNotificationsRequest mocks base method 6224 func (m *MockEC2API) DeleteVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DeleteVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DeleteVpcEndpointConnectionNotificationsOutput) { 6225 m.ctrl.T.Helper() 6226 ret := m.ctrl.Call(m, "DeleteVpcEndpointConnectionNotificationsRequest", arg0) 6227 ret0, _ := ret[0].(*request.Request) 6228 ret1, _ := ret[1].(*ec2.DeleteVpcEndpointConnectionNotificationsOutput) 6229 return ret0, ret1 6230 } 6231 6232 // DeleteVpcEndpointConnectionNotificationsRequest indicates an expected call of DeleteVpcEndpointConnectionNotificationsRequest 6233 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call { 6234 mr.mock.ctrl.T.Helper() 6235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointConnectionNotificationsRequest), arg0) 6236 } 6237 6238 // DeleteVpcEndpointServiceConfigurations mocks base method 6239 func (m *MockEC2API) DeleteVpcEndpointServiceConfigurations(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) { 6240 m.ctrl.T.Helper() 6241 ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurations", arg0) 6242 ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) 6243 ret1, _ := ret[1].(error) 6244 return ret0, ret1 6245 } 6246 6247 // DeleteVpcEndpointServiceConfigurations indicates an expected call of DeleteVpcEndpointServiceConfigurations 6248 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call { 6249 mr.mock.ctrl.T.Helper() 6250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurations), arg0) 6251 } 6252 6253 // DeleteVpcEndpointServiceConfigurationsWithContext mocks base method 6254 func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsWithContext(arg0 aws.Context, arg1 *ec2.DeleteVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointServiceConfigurationsOutput, error) { 6255 m.ctrl.T.Helper() 6256 varargs := []interface{}{arg0, arg1} 6257 for _, a := range arg2 { 6258 varargs = append(varargs, a) 6259 } 6260 ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsWithContext", varargs...) 6261 ret0, _ := ret[0].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) 6262 ret1, _ := ret[1].(error) 6263 return ret0, ret1 6264 } 6265 6266 // DeleteVpcEndpointServiceConfigurationsWithContext indicates an expected call of DeleteVpcEndpointServiceConfigurationsWithContext 6267 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6268 mr.mock.ctrl.T.Helper() 6269 varargs := append([]interface{}{arg0, arg1}, arg2...) 6270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsWithContext), varargs...) 6271 } 6272 6273 // DeleteVpcEndpointServiceConfigurationsRequest mocks base method 6274 func (m *MockEC2API) DeleteVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DeleteVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DeleteVpcEndpointServiceConfigurationsOutput) { 6275 m.ctrl.T.Helper() 6276 ret := m.ctrl.Call(m, "DeleteVpcEndpointServiceConfigurationsRequest", arg0) 6277 ret0, _ := ret[0].(*request.Request) 6278 ret1, _ := ret[1].(*ec2.DeleteVpcEndpointServiceConfigurationsOutput) 6279 return ret0, ret1 6280 } 6281 6282 // DeleteVpcEndpointServiceConfigurationsRequest indicates an expected call of DeleteVpcEndpointServiceConfigurationsRequest 6283 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call { 6284 mr.mock.ctrl.T.Helper() 6285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointServiceConfigurationsRequest), arg0) 6286 } 6287 6288 // DeleteVpcEndpoints mocks base method 6289 func (m *MockEC2API) DeleteVpcEndpoints(arg0 *ec2.DeleteVpcEndpointsInput) (*ec2.DeleteVpcEndpointsOutput, error) { 6290 m.ctrl.T.Helper() 6291 ret := m.ctrl.Call(m, "DeleteVpcEndpoints", arg0) 6292 ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput) 6293 ret1, _ := ret[1].(error) 6294 return ret0, ret1 6295 } 6296 6297 // DeleteVpcEndpoints indicates an expected call of DeleteVpcEndpoints 6298 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpoints(arg0 interface{}) *gomock.Call { 6299 mr.mock.ctrl.T.Helper() 6300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpoints), arg0) 6301 } 6302 6303 // DeleteVpcEndpointsWithContext mocks base method 6304 func (m *MockEC2API) DeleteVpcEndpointsWithContext(arg0 aws.Context, arg1 *ec2.DeleteVpcEndpointsInput, arg2 ...request.Option) (*ec2.DeleteVpcEndpointsOutput, error) { 6305 m.ctrl.T.Helper() 6306 varargs := []interface{}{arg0, arg1} 6307 for _, a := range arg2 { 6308 varargs = append(varargs, a) 6309 } 6310 ret := m.ctrl.Call(m, "DeleteVpcEndpointsWithContext", varargs...) 6311 ret0, _ := ret[0].(*ec2.DeleteVpcEndpointsOutput) 6312 ret1, _ := ret[1].(error) 6313 return ret0, ret1 6314 } 6315 6316 // DeleteVpcEndpointsWithContext indicates an expected call of DeleteVpcEndpointsWithContext 6317 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6318 mr.mock.ctrl.T.Helper() 6319 varargs := append([]interface{}{arg0, arg1}, arg2...) 6320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointsWithContext), varargs...) 6321 } 6322 6323 // DeleteVpcEndpointsRequest mocks base method 6324 func (m *MockEC2API) DeleteVpcEndpointsRequest(arg0 *ec2.DeleteVpcEndpointsInput) (*request.Request, *ec2.DeleteVpcEndpointsOutput) { 6325 m.ctrl.T.Helper() 6326 ret := m.ctrl.Call(m, "DeleteVpcEndpointsRequest", arg0) 6327 ret0, _ := ret[0].(*request.Request) 6328 ret1, _ := ret[1].(*ec2.DeleteVpcEndpointsOutput) 6329 return ret0, ret1 6330 } 6331 6332 // DeleteVpcEndpointsRequest indicates an expected call of DeleteVpcEndpointsRequest 6333 func (mr *MockEC2APIMockRecorder) DeleteVpcEndpointsRequest(arg0 interface{}) *gomock.Call { 6334 mr.mock.ctrl.T.Helper() 6335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcEndpointsRequest), arg0) 6336 } 6337 6338 // DeleteVpcPeeringConnection mocks base method 6339 func (m *MockEC2API) DeleteVpcPeeringConnection(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*ec2.DeleteVpcPeeringConnectionOutput, error) { 6340 m.ctrl.T.Helper() 6341 ret := m.ctrl.Call(m, "DeleteVpcPeeringConnection", arg0) 6342 ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput) 6343 ret1, _ := ret[1].(error) 6344 return ret0, ret1 6345 } 6346 6347 // DeleteVpcPeeringConnection indicates an expected call of DeleteVpcPeeringConnection 6348 func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnection(arg0 interface{}) *gomock.Call { 6349 mr.mock.ctrl.T.Helper() 6350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnection), arg0) 6351 } 6352 6353 // DeleteVpcPeeringConnectionWithContext mocks base method 6354 func (m *MockEC2API) DeleteVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *ec2.DeleteVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpcPeeringConnectionOutput, error) { 6355 m.ctrl.T.Helper() 6356 varargs := []interface{}{arg0, arg1} 6357 for _, a := range arg2 { 6358 varargs = append(varargs, a) 6359 } 6360 ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionWithContext", varargs...) 6361 ret0, _ := ret[0].(*ec2.DeleteVpcPeeringConnectionOutput) 6362 ret1, _ := ret[1].(error) 6363 return ret0, ret1 6364 } 6365 6366 // DeleteVpcPeeringConnectionWithContext indicates an expected call of DeleteVpcPeeringConnectionWithContext 6367 func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6368 mr.mock.ctrl.T.Helper() 6369 varargs := append([]interface{}{arg0, arg1}, arg2...) 6370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnectionWithContext), varargs...) 6371 } 6372 6373 // DeleteVpcPeeringConnectionRequest mocks base method 6374 func (m *MockEC2API) DeleteVpcPeeringConnectionRequest(arg0 *ec2.DeleteVpcPeeringConnectionInput) (*request.Request, *ec2.DeleteVpcPeeringConnectionOutput) { 6375 m.ctrl.T.Helper() 6376 ret := m.ctrl.Call(m, "DeleteVpcPeeringConnectionRequest", arg0) 6377 ret0, _ := ret[0].(*request.Request) 6378 ret1, _ := ret[1].(*ec2.DeleteVpcPeeringConnectionOutput) 6379 return ret0, ret1 6380 } 6381 6382 // DeleteVpcPeeringConnectionRequest indicates an expected call of DeleteVpcPeeringConnectionRequest 6383 func (mr *MockEC2APIMockRecorder) DeleteVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { 6384 mr.mock.ctrl.T.Helper() 6385 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpcPeeringConnectionRequest), arg0) 6386 } 6387 6388 // DeleteVpnConnection mocks base method 6389 func (m *MockEC2API) DeleteVpnConnection(arg0 *ec2.DeleteVpnConnectionInput) (*ec2.DeleteVpnConnectionOutput, error) { 6390 m.ctrl.T.Helper() 6391 ret := m.ctrl.Call(m, "DeleteVpnConnection", arg0) 6392 ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput) 6393 ret1, _ := ret[1].(error) 6394 return ret0, ret1 6395 } 6396 6397 // DeleteVpnConnection indicates an expected call of DeleteVpnConnection 6398 func (mr *MockEC2APIMockRecorder) DeleteVpnConnection(arg0 interface{}) *gomock.Call { 6399 mr.mock.ctrl.T.Helper() 6400 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnection", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnection), arg0) 6401 } 6402 6403 // DeleteVpnConnectionWithContext mocks base method 6404 func (m *MockEC2API) DeleteVpnConnectionWithContext(arg0 aws.Context, arg1 *ec2.DeleteVpnConnectionInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionOutput, error) { 6405 m.ctrl.T.Helper() 6406 varargs := []interface{}{arg0, arg1} 6407 for _, a := range arg2 { 6408 varargs = append(varargs, a) 6409 } 6410 ret := m.ctrl.Call(m, "DeleteVpnConnectionWithContext", varargs...) 6411 ret0, _ := ret[0].(*ec2.DeleteVpnConnectionOutput) 6412 ret1, _ := ret[1].(error) 6413 return ret0, ret1 6414 } 6415 6416 // DeleteVpnConnectionWithContext indicates an expected call of DeleteVpnConnectionWithContext 6417 func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6418 mr.mock.ctrl.T.Helper() 6419 varargs := append([]interface{}{arg0, arg1}, arg2...) 6420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionWithContext), varargs...) 6421 } 6422 6423 // DeleteVpnConnectionRequest mocks base method 6424 func (m *MockEC2API) DeleteVpnConnectionRequest(arg0 *ec2.DeleteVpnConnectionInput) (*request.Request, *ec2.DeleteVpnConnectionOutput) { 6425 m.ctrl.T.Helper() 6426 ret := m.ctrl.Call(m, "DeleteVpnConnectionRequest", arg0) 6427 ret0, _ := ret[0].(*request.Request) 6428 ret1, _ := ret[1].(*ec2.DeleteVpnConnectionOutput) 6429 return ret0, ret1 6430 } 6431 6432 // DeleteVpnConnectionRequest indicates an expected call of DeleteVpnConnectionRequest 6433 func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRequest(arg0 interface{}) *gomock.Call { 6434 mr.mock.ctrl.T.Helper() 6435 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRequest), arg0) 6436 } 6437 6438 // DeleteVpnConnectionRoute mocks base method 6439 func (m *MockEC2API) DeleteVpnConnectionRoute(arg0 *ec2.DeleteVpnConnectionRouteInput) (*ec2.DeleteVpnConnectionRouteOutput, error) { 6440 m.ctrl.T.Helper() 6441 ret := m.ctrl.Call(m, "DeleteVpnConnectionRoute", arg0) 6442 ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput) 6443 ret1, _ := ret[1].(error) 6444 return ret0, ret1 6445 } 6446 6447 // DeleteVpnConnectionRoute indicates an expected call of DeleteVpnConnectionRoute 6448 func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRoute(arg0 interface{}) *gomock.Call { 6449 mr.mock.ctrl.T.Helper() 6450 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRoute", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRoute), arg0) 6451 } 6452 6453 // DeleteVpnConnectionRouteWithContext mocks base method 6454 func (m *MockEC2API) DeleteVpnConnectionRouteWithContext(arg0 aws.Context, arg1 *ec2.DeleteVpnConnectionRouteInput, arg2 ...request.Option) (*ec2.DeleteVpnConnectionRouteOutput, error) { 6455 m.ctrl.T.Helper() 6456 varargs := []interface{}{arg0, arg1} 6457 for _, a := range arg2 { 6458 varargs = append(varargs, a) 6459 } 6460 ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteWithContext", varargs...) 6461 ret0, _ := ret[0].(*ec2.DeleteVpnConnectionRouteOutput) 6462 ret1, _ := ret[1].(error) 6463 return ret0, ret1 6464 } 6465 6466 // DeleteVpnConnectionRouteWithContext indicates an expected call of DeleteVpnConnectionRouteWithContext 6467 func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6468 mr.mock.ctrl.T.Helper() 6469 varargs := append([]interface{}{arg0, arg1}, arg2...) 6470 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRouteWithContext), varargs...) 6471 } 6472 6473 // DeleteVpnConnectionRouteRequest mocks base method 6474 func (m *MockEC2API) DeleteVpnConnectionRouteRequest(arg0 *ec2.DeleteVpnConnectionRouteInput) (*request.Request, *ec2.DeleteVpnConnectionRouteOutput) { 6475 m.ctrl.T.Helper() 6476 ret := m.ctrl.Call(m, "DeleteVpnConnectionRouteRequest", arg0) 6477 ret0, _ := ret[0].(*request.Request) 6478 ret1, _ := ret[1].(*ec2.DeleteVpnConnectionRouteOutput) 6479 return ret0, ret1 6480 } 6481 6482 // DeleteVpnConnectionRouteRequest indicates an expected call of DeleteVpnConnectionRouteRequest 6483 func (mr *MockEC2APIMockRecorder) DeleteVpnConnectionRouteRequest(arg0 interface{}) *gomock.Call { 6484 mr.mock.ctrl.T.Helper() 6485 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnConnectionRouteRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnConnectionRouteRequest), arg0) 6486 } 6487 6488 // DeleteVpnGateway mocks base method 6489 func (m *MockEC2API) DeleteVpnGateway(arg0 *ec2.DeleteVpnGatewayInput) (*ec2.DeleteVpnGatewayOutput, error) { 6490 m.ctrl.T.Helper() 6491 ret := m.ctrl.Call(m, "DeleteVpnGateway", arg0) 6492 ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput) 6493 ret1, _ := ret[1].(error) 6494 return ret0, ret1 6495 } 6496 6497 // DeleteVpnGateway indicates an expected call of DeleteVpnGateway 6498 func (mr *MockEC2APIMockRecorder) DeleteVpnGateway(arg0 interface{}) *gomock.Call { 6499 mr.mock.ctrl.T.Helper() 6500 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGateway), arg0) 6501 } 6502 6503 // DeleteVpnGatewayWithContext mocks base method 6504 func (m *MockEC2API) DeleteVpnGatewayWithContext(arg0 aws.Context, arg1 *ec2.DeleteVpnGatewayInput, arg2 ...request.Option) (*ec2.DeleteVpnGatewayOutput, error) { 6505 m.ctrl.T.Helper() 6506 varargs := []interface{}{arg0, arg1} 6507 for _, a := range arg2 { 6508 varargs = append(varargs, a) 6509 } 6510 ret := m.ctrl.Call(m, "DeleteVpnGatewayWithContext", varargs...) 6511 ret0, _ := ret[0].(*ec2.DeleteVpnGatewayOutput) 6512 ret1, _ := ret[1].(error) 6513 return ret0, ret1 6514 } 6515 6516 // DeleteVpnGatewayWithContext indicates an expected call of DeleteVpnGatewayWithContext 6517 func (mr *MockEC2APIMockRecorder) DeleteVpnGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6518 mr.mock.ctrl.T.Helper() 6519 varargs := append([]interface{}{arg0, arg1}, arg2...) 6520 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGatewayWithContext), varargs...) 6521 } 6522 6523 // DeleteVpnGatewayRequest mocks base method 6524 func (m *MockEC2API) DeleteVpnGatewayRequest(arg0 *ec2.DeleteVpnGatewayInput) (*request.Request, *ec2.DeleteVpnGatewayOutput) { 6525 m.ctrl.T.Helper() 6526 ret := m.ctrl.Call(m, "DeleteVpnGatewayRequest", arg0) 6527 ret0, _ := ret[0].(*request.Request) 6528 ret1, _ := ret[1].(*ec2.DeleteVpnGatewayOutput) 6529 return ret0, ret1 6530 } 6531 6532 // DeleteVpnGatewayRequest indicates an expected call of DeleteVpnGatewayRequest 6533 func (mr *MockEC2APIMockRecorder) DeleteVpnGatewayRequest(arg0 interface{}) *gomock.Call { 6534 mr.mock.ctrl.T.Helper() 6535 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DeleteVpnGatewayRequest), arg0) 6536 } 6537 6538 // DeprovisionByoipCidr mocks base method 6539 func (m *MockEC2API) DeprovisionByoipCidr(arg0 *ec2.DeprovisionByoipCidrInput) (*ec2.DeprovisionByoipCidrOutput, error) { 6540 m.ctrl.T.Helper() 6541 ret := m.ctrl.Call(m, "DeprovisionByoipCidr", arg0) 6542 ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput) 6543 ret1, _ := ret[1].(error) 6544 return ret0, ret1 6545 } 6546 6547 // DeprovisionByoipCidr indicates an expected call of DeprovisionByoipCidr 6548 func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidr(arg0 interface{}) *gomock.Call { 6549 mr.mock.ctrl.T.Helper() 6550 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidr), arg0) 6551 } 6552 6553 // DeprovisionByoipCidrWithContext mocks base method 6554 func (m *MockEC2API) DeprovisionByoipCidrWithContext(arg0 aws.Context, arg1 *ec2.DeprovisionByoipCidrInput, arg2 ...request.Option) (*ec2.DeprovisionByoipCidrOutput, error) { 6555 m.ctrl.T.Helper() 6556 varargs := []interface{}{arg0, arg1} 6557 for _, a := range arg2 { 6558 varargs = append(varargs, a) 6559 } 6560 ret := m.ctrl.Call(m, "DeprovisionByoipCidrWithContext", varargs...) 6561 ret0, _ := ret[0].(*ec2.DeprovisionByoipCidrOutput) 6562 ret1, _ := ret[1].(error) 6563 return ret0, ret1 6564 } 6565 6566 // DeprovisionByoipCidrWithContext indicates an expected call of DeprovisionByoipCidrWithContext 6567 func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6568 mr.mock.ctrl.T.Helper() 6569 varargs := append([]interface{}{arg0, arg1}, arg2...) 6570 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidrWithContext), varargs...) 6571 } 6572 6573 // DeprovisionByoipCidrRequest mocks base method 6574 func (m *MockEC2API) DeprovisionByoipCidrRequest(arg0 *ec2.DeprovisionByoipCidrInput) (*request.Request, *ec2.DeprovisionByoipCidrOutput) { 6575 m.ctrl.T.Helper() 6576 ret := m.ctrl.Call(m, "DeprovisionByoipCidrRequest", arg0) 6577 ret0, _ := ret[0].(*request.Request) 6578 ret1, _ := ret[1].(*ec2.DeprovisionByoipCidrOutput) 6579 return ret0, ret1 6580 } 6581 6582 // DeprovisionByoipCidrRequest indicates an expected call of DeprovisionByoipCidrRequest 6583 func (mr *MockEC2APIMockRecorder) DeprovisionByoipCidrRequest(arg0 interface{}) *gomock.Call { 6584 mr.mock.ctrl.T.Helper() 6585 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeprovisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).DeprovisionByoipCidrRequest), arg0) 6586 } 6587 6588 // DeregisterImage mocks base method 6589 func (m *MockEC2API) DeregisterImage(arg0 *ec2.DeregisterImageInput) (*ec2.DeregisterImageOutput, error) { 6590 m.ctrl.T.Helper() 6591 ret := m.ctrl.Call(m, "DeregisterImage", arg0) 6592 ret0, _ := ret[0].(*ec2.DeregisterImageOutput) 6593 ret1, _ := ret[1].(error) 6594 return ret0, ret1 6595 } 6596 6597 // DeregisterImage indicates an expected call of DeregisterImage 6598 func (mr *MockEC2APIMockRecorder) DeregisterImage(arg0 interface{}) *gomock.Call { 6599 mr.mock.ctrl.T.Helper() 6600 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImage", reflect.TypeOf((*MockEC2API)(nil).DeregisterImage), arg0) 6601 } 6602 6603 // DeregisterImageWithContext mocks base method 6604 func (m *MockEC2API) DeregisterImageWithContext(arg0 aws.Context, arg1 *ec2.DeregisterImageInput, arg2 ...request.Option) (*ec2.DeregisterImageOutput, error) { 6605 m.ctrl.T.Helper() 6606 varargs := []interface{}{arg0, arg1} 6607 for _, a := range arg2 { 6608 varargs = append(varargs, a) 6609 } 6610 ret := m.ctrl.Call(m, "DeregisterImageWithContext", varargs...) 6611 ret0, _ := ret[0].(*ec2.DeregisterImageOutput) 6612 ret1, _ := ret[1].(error) 6613 return ret0, ret1 6614 } 6615 6616 // DeregisterImageWithContext indicates an expected call of DeregisterImageWithContext 6617 func (mr *MockEC2APIMockRecorder) DeregisterImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6618 mr.mock.ctrl.T.Helper() 6619 varargs := append([]interface{}{arg0, arg1}, arg2...) 6620 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImageWithContext", reflect.TypeOf((*MockEC2API)(nil).DeregisterImageWithContext), varargs...) 6621 } 6622 6623 // DeregisterImageRequest mocks base method 6624 func (m *MockEC2API) DeregisterImageRequest(arg0 *ec2.DeregisterImageInput) (*request.Request, *ec2.DeregisterImageOutput) { 6625 m.ctrl.T.Helper() 6626 ret := m.ctrl.Call(m, "DeregisterImageRequest", arg0) 6627 ret0, _ := ret[0].(*request.Request) 6628 ret1, _ := ret[1].(*ec2.DeregisterImageOutput) 6629 return ret0, ret1 6630 } 6631 6632 // DeregisterImageRequest indicates an expected call of DeregisterImageRequest 6633 func (mr *MockEC2APIMockRecorder) DeregisterImageRequest(arg0 interface{}) *gomock.Call { 6634 mr.mock.ctrl.T.Helper() 6635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeregisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).DeregisterImageRequest), arg0) 6636 } 6637 6638 // DescribeAccountAttributes mocks base method 6639 func (m *MockEC2API) DescribeAccountAttributes(arg0 *ec2.DescribeAccountAttributesInput) (*ec2.DescribeAccountAttributesOutput, error) { 6640 m.ctrl.T.Helper() 6641 ret := m.ctrl.Call(m, "DescribeAccountAttributes", arg0) 6642 ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput) 6643 ret1, _ := ret[1].(error) 6644 return ret0, ret1 6645 } 6646 6647 // DescribeAccountAttributes indicates an expected call of DescribeAccountAttributes 6648 func (mr *MockEC2APIMockRecorder) DescribeAccountAttributes(arg0 interface{}) *gomock.Call { 6649 mr.mock.ctrl.T.Helper() 6650 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributes", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributes), arg0) 6651 } 6652 6653 // DescribeAccountAttributesWithContext mocks base method 6654 func (m *MockEC2API) DescribeAccountAttributesWithContext(arg0 aws.Context, arg1 *ec2.DescribeAccountAttributesInput, arg2 ...request.Option) (*ec2.DescribeAccountAttributesOutput, error) { 6655 m.ctrl.T.Helper() 6656 varargs := []interface{}{arg0, arg1} 6657 for _, a := range arg2 { 6658 varargs = append(varargs, a) 6659 } 6660 ret := m.ctrl.Call(m, "DescribeAccountAttributesWithContext", varargs...) 6661 ret0, _ := ret[0].(*ec2.DescribeAccountAttributesOutput) 6662 ret1, _ := ret[1].(error) 6663 return ret0, ret1 6664 } 6665 6666 // DescribeAccountAttributesWithContext indicates an expected call of DescribeAccountAttributesWithContext 6667 func (mr *MockEC2APIMockRecorder) DescribeAccountAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6668 mr.mock.ctrl.T.Helper() 6669 varargs := append([]interface{}{arg0, arg1}, arg2...) 6670 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributesWithContext), varargs...) 6671 } 6672 6673 // DescribeAccountAttributesRequest mocks base method 6674 func (m *MockEC2API) DescribeAccountAttributesRequest(arg0 *ec2.DescribeAccountAttributesInput) (*request.Request, *ec2.DescribeAccountAttributesOutput) { 6675 m.ctrl.T.Helper() 6676 ret := m.ctrl.Call(m, "DescribeAccountAttributesRequest", arg0) 6677 ret0, _ := ret[0].(*request.Request) 6678 ret1, _ := ret[1].(*ec2.DescribeAccountAttributesOutput) 6679 return ret0, ret1 6680 } 6681 6682 // DescribeAccountAttributesRequest indicates an expected call of DescribeAccountAttributesRequest 6683 func (mr *MockEC2APIMockRecorder) DescribeAccountAttributesRequest(arg0 interface{}) *gomock.Call { 6684 mr.mock.ctrl.T.Helper() 6685 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAccountAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAccountAttributesRequest), arg0) 6686 } 6687 6688 // DescribeAddresses mocks base method 6689 func (m *MockEC2API) DescribeAddresses(arg0 *ec2.DescribeAddressesInput) (*ec2.DescribeAddressesOutput, error) { 6690 m.ctrl.T.Helper() 6691 ret := m.ctrl.Call(m, "DescribeAddresses", arg0) 6692 ret0, _ := ret[0].(*ec2.DescribeAddressesOutput) 6693 ret1, _ := ret[1].(error) 6694 return ret0, ret1 6695 } 6696 6697 // DescribeAddresses indicates an expected call of DescribeAddresses 6698 func (mr *MockEC2APIMockRecorder) DescribeAddresses(arg0 interface{}) *gomock.Call { 6699 mr.mock.ctrl.T.Helper() 6700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeAddresses), arg0) 6701 } 6702 6703 // DescribeAddressesWithContext mocks base method 6704 func (m *MockEC2API) DescribeAddressesWithContext(arg0 aws.Context, arg1 *ec2.DescribeAddressesInput, arg2 ...request.Option) (*ec2.DescribeAddressesOutput, error) { 6705 m.ctrl.T.Helper() 6706 varargs := []interface{}{arg0, arg1} 6707 for _, a := range arg2 { 6708 varargs = append(varargs, a) 6709 } 6710 ret := m.ctrl.Call(m, "DescribeAddressesWithContext", varargs...) 6711 ret0, _ := ret[0].(*ec2.DescribeAddressesOutput) 6712 ret1, _ := ret[1].(error) 6713 return ret0, ret1 6714 } 6715 6716 // DescribeAddressesWithContext indicates an expected call of DescribeAddressesWithContext 6717 func (mr *MockEC2APIMockRecorder) DescribeAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6718 mr.mock.ctrl.T.Helper() 6719 varargs := append([]interface{}{arg0, arg1}, arg2...) 6720 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesWithContext), varargs...) 6721 } 6722 6723 // DescribeAddressesRequest mocks base method 6724 func (m *MockEC2API) DescribeAddressesRequest(arg0 *ec2.DescribeAddressesInput) (*request.Request, *ec2.DescribeAddressesOutput) { 6725 m.ctrl.T.Helper() 6726 ret := m.ctrl.Call(m, "DescribeAddressesRequest", arg0) 6727 ret0, _ := ret[0].(*request.Request) 6728 ret1, _ := ret[1].(*ec2.DescribeAddressesOutput) 6729 return ret0, ret1 6730 } 6731 6732 // DescribeAddressesRequest indicates an expected call of DescribeAddressesRequest 6733 func (mr *MockEC2APIMockRecorder) DescribeAddressesRequest(arg0 interface{}) *gomock.Call { 6734 mr.mock.ctrl.T.Helper() 6735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAddressesRequest), arg0) 6736 } 6737 6738 // DescribeAggregateIdFormat mocks base method 6739 func (m *MockEC2API) DescribeAggregateIdFormat(arg0 *ec2.DescribeAggregateIdFormatInput) (*ec2.DescribeAggregateIdFormatOutput, error) { 6740 m.ctrl.T.Helper() 6741 ret := m.ctrl.Call(m, "DescribeAggregateIdFormat", arg0) 6742 ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput) 6743 ret1, _ := ret[1].(error) 6744 return ret0, ret1 6745 } 6746 6747 // DescribeAggregateIdFormat indicates an expected call of DescribeAggregateIdFormat 6748 func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormat(arg0 interface{}) *gomock.Call { 6749 mr.mock.ctrl.T.Helper() 6750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormat), arg0) 6751 } 6752 6753 // DescribeAggregateIdFormatWithContext mocks base method 6754 func (m *MockEC2API) DescribeAggregateIdFormatWithContext(arg0 aws.Context, arg1 *ec2.DescribeAggregateIdFormatInput, arg2 ...request.Option) (*ec2.DescribeAggregateIdFormatOutput, error) { 6755 m.ctrl.T.Helper() 6756 varargs := []interface{}{arg0, arg1} 6757 for _, a := range arg2 { 6758 varargs = append(varargs, a) 6759 } 6760 ret := m.ctrl.Call(m, "DescribeAggregateIdFormatWithContext", varargs...) 6761 ret0, _ := ret[0].(*ec2.DescribeAggregateIdFormatOutput) 6762 ret1, _ := ret[1].(error) 6763 return ret0, ret1 6764 } 6765 6766 // DescribeAggregateIdFormatWithContext indicates an expected call of DescribeAggregateIdFormatWithContext 6767 func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6768 mr.mock.ctrl.T.Helper() 6769 varargs := append([]interface{}{arg0, arg1}, arg2...) 6770 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormatWithContext), varargs...) 6771 } 6772 6773 // DescribeAggregateIdFormatRequest mocks base method 6774 func (m *MockEC2API) DescribeAggregateIdFormatRequest(arg0 *ec2.DescribeAggregateIdFormatInput) (*request.Request, *ec2.DescribeAggregateIdFormatOutput) { 6775 m.ctrl.T.Helper() 6776 ret := m.ctrl.Call(m, "DescribeAggregateIdFormatRequest", arg0) 6777 ret0, _ := ret[0].(*request.Request) 6778 ret1, _ := ret[1].(*ec2.DescribeAggregateIdFormatOutput) 6779 return ret0, ret1 6780 } 6781 6782 // DescribeAggregateIdFormatRequest indicates an expected call of DescribeAggregateIdFormatRequest 6783 func (mr *MockEC2APIMockRecorder) DescribeAggregateIdFormatRequest(arg0 interface{}) *gomock.Call { 6784 mr.mock.ctrl.T.Helper() 6785 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAggregateIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAggregateIdFormatRequest), arg0) 6786 } 6787 6788 // DescribeAvailabilityZones mocks base method 6789 func (m *MockEC2API) DescribeAvailabilityZones(arg0 *ec2.DescribeAvailabilityZonesInput) (*ec2.DescribeAvailabilityZonesOutput, error) { 6790 m.ctrl.T.Helper() 6791 ret := m.ctrl.Call(m, "DescribeAvailabilityZones", arg0) 6792 ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput) 6793 ret1, _ := ret[1].(error) 6794 return ret0, ret1 6795 } 6796 6797 // DescribeAvailabilityZones indicates an expected call of DescribeAvailabilityZones 6798 func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZones(arg0 interface{}) *gomock.Call { 6799 mr.mock.ctrl.T.Helper() 6800 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZones", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZones), arg0) 6801 } 6802 6803 // DescribeAvailabilityZonesWithContext mocks base method 6804 func (m *MockEC2API) DescribeAvailabilityZonesWithContext(arg0 aws.Context, arg1 *ec2.DescribeAvailabilityZonesInput, arg2 ...request.Option) (*ec2.DescribeAvailabilityZonesOutput, error) { 6805 m.ctrl.T.Helper() 6806 varargs := []interface{}{arg0, arg1} 6807 for _, a := range arg2 { 6808 varargs = append(varargs, a) 6809 } 6810 ret := m.ctrl.Call(m, "DescribeAvailabilityZonesWithContext", varargs...) 6811 ret0, _ := ret[0].(*ec2.DescribeAvailabilityZonesOutput) 6812 ret1, _ := ret[1].(error) 6813 return ret0, ret1 6814 } 6815 6816 // DescribeAvailabilityZonesWithContext indicates an expected call of DescribeAvailabilityZonesWithContext 6817 func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZonesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6818 mr.mock.ctrl.T.Helper() 6819 varargs := append([]interface{}{arg0, arg1}, arg2...) 6820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZonesWithContext), varargs...) 6821 } 6822 6823 // DescribeAvailabilityZonesRequest mocks base method 6824 func (m *MockEC2API) DescribeAvailabilityZonesRequest(arg0 *ec2.DescribeAvailabilityZonesInput) (*request.Request, *ec2.DescribeAvailabilityZonesOutput) { 6825 m.ctrl.T.Helper() 6826 ret := m.ctrl.Call(m, "DescribeAvailabilityZonesRequest", arg0) 6827 ret0, _ := ret[0].(*request.Request) 6828 ret1, _ := ret[1].(*ec2.DescribeAvailabilityZonesOutput) 6829 return ret0, ret1 6830 } 6831 6832 // DescribeAvailabilityZonesRequest indicates an expected call of DescribeAvailabilityZonesRequest 6833 func (mr *MockEC2APIMockRecorder) DescribeAvailabilityZonesRequest(arg0 interface{}) *gomock.Call { 6834 mr.mock.ctrl.T.Helper() 6835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeAvailabilityZonesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeAvailabilityZonesRequest), arg0) 6836 } 6837 6838 // DescribeBundleTasks mocks base method 6839 func (m *MockEC2API) DescribeBundleTasks(arg0 *ec2.DescribeBundleTasksInput) (*ec2.DescribeBundleTasksOutput, error) { 6840 m.ctrl.T.Helper() 6841 ret := m.ctrl.Call(m, "DescribeBundleTasks", arg0) 6842 ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput) 6843 ret1, _ := ret[1].(error) 6844 return ret0, ret1 6845 } 6846 6847 // DescribeBundleTasks indicates an expected call of DescribeBundleTasks 6848 func (mr *MockEC2APIMockRecorder) DescribeBundleTasks(arg0 interface{}) *gomock.Call { 6849 mr.mock.ctrl.T.Helper() 6850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasks), arg0) 6851 } 6852 6853 // DescribeBundleTasksWithContext mocks base method 6854 func (m *MockEC2API) DescribeBundleTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeBundleTasksInput, arg2 ...request.Option) (*ec2.DescribeBundleTasksOutput, error) { 6855 m.ctrl.T.Helper() 6856 varargs := []interface{}{arg0, arg1} 6857 for _, a := range arg2 { 6858 varargs = append(varargs, a) 6859 } 6860 ret := m.ctrl.Call(m, "DescribeBundleTasksWithContext", varargs...) 6861 ret0, _ := ret[0].(*ec2.DescribeBundleTasksOutput) 6862 ret1, _ := ret[1].(error) 6863 return ret0, ret1 6864 } 6865 6866 // DescribeBundleTasksWithContext indicates an expected call of DescribeBundleTasksWithContext 6867 func (mr *MockEC2APIMockRecorder) DescribeBundleTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6868 mr.mock.ctrl.T.Helper() 6869 varargs := append([]interface{}{arg0, arg1}, arg2...) 6870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasksWithContext), varargs...) 6871 } 6872 6873 // DescribeBundleTasksRequest mocks base method 6874 func (m *MockEC2API) DescribeBundleTasksRequest(arg0 *ec2.DescribeBundleTasksInput) (*request.Request, *ec2.DescribeBundleTasksOutput) { 6875 m.ctrl.T.Helper() 6876 ret := m.ctrl.Call(m, "DescribeBundleTasksRequest", arg0) 6877 ret0, _ := ret[0].(*request.Request) 6878 ret1, _ := ret[1].(*ec2.DescribeBundleTasksOutput) 6879 return ret0, ret1 6880 } 6881 6882 // DescribeBundleTasksRequest indicates an expected call of DescribeBundleTasksRequest 6883 func (mr *MockEC2APIMockRecorder) DescribeBundleTasksRequest(arg0 interface{}) *gomock.Call { 6884 mr.mock.ctrl.T.Helper() 6885 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeBundleTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeBundleTasksRequest), arg0) 6886 } 6887 6888 // DescribeByoipCidrs mocks base method 6889 func (m *MockEC2API) DescribeByoipCidrs(arg0 *ec2.DescribeByoipCidrsInput) (*ec2.DescribeByoipCidrsOutput, error) { 6890 m.ctrl.T.Helper() 6891 ret := m.ctrl.Call(m, "DescribeByoipCidrs", arg0) 6892 ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput) 6893 ret1, _ := ret[1].(error) 6894 return ret0, ret1 6895 } 6896 6897 // DescribeByoipCidrs indicates an expected call of DescribeByoipCidrs 6898 func (mr *MockEC2APIMockRecorder) DescribeByoipCidrs(arg0 interface{}) *gomock.Call { 6899 mr.mock.ctrl.T.Helper() 6900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrs", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrs), arg0) 6901 } 6902 6903 // DescribeByoipCidrsWithContext mocks base method 6904 func (m *MockEC2API) DescribeByoipCidrsWithContext(arg0 aws.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 ...request.Option) (*ec2.DescribeByoipCidrsOutput, error) { 6905 m.ctrl.T.Helper() 6906 varargs := []interface{}{arg0, arg1} 6907 for _, a := range arg2 { 6908 varargs = append(varargs, a) 6909 } 6910 ret := m.ctrl.Call(m, "DescribeByoipCidrsWithContext", varargs...) 6911 ret0, _ := ret[0].(*ec2.DescribeByoipCidrsOutput) 6912 ret1, _ := ret[1].(error) 6913 return ret0, ret1 6914 } 6915 6916 // DescribeByoipCidrsWithContext indicates an expected call of DescribeByoipCidrsWithContext 6917 func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 6918 mr.mock.ctrl.T.Helper() 6919 varargs := append([]interface{}{arg0, arg1}, arg2...) 6920 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsWithContext), varargs...) 6921 } 6922 6923 // DescribeByoipCidrsRequest mocks base method 6924 func (m *MockEC2API) DescribeByoipCidrsRequest(arg0 *ec2.DescribeByoipCidrsInput) (*request.Request, *ec2.DescribeByoipCidrsOutput) { 6925 m.ctrl.T.Helper() 6926 ret := m.ctrl.Call(m, "DescribeByoipCidrsRequest", arg0) 6927 ret0, _ := ret[0].(*request.Request) 6928 ret1, _ := ret[1].(*ec2.DescribeByoipCidrsOutput) 6929 return ret0, ret1 6930 } 6931 6932 // DescribeByoipCidrsRequest indicates an expected call of DescribeByoipCidrsRequest 6933 func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsRequest(arg0 interface{}) *gomock.Call { 6934 mr.mock.ctrl.T.Helper() 6935 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsRequest), arg0) 6936 } 6937 6938 // DescribeByoipCidrsPages mocks base method 6939 func (m *MockEC2API) DescribeByoipCidrsPages(arg0 *ec2.DescribeByoipCidrsInput, arg1 func(*ec2.DescribeByoipCidrsOutput, bool) bool) error { 6940 m.ctrl.T.Helper() 6941 ret := m.ctrl.Call(m, "DescribeByoipCidrsPages", arg0, arg1) 6942 ret0, _ := ret[0].(error) 6943 return ret0 6944 } 6945 6946 // DescribeByoipCidrsPages indicates an expected call of DescribeByoipCidrsPages 6947 func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsPages(arg0, arg1 interface{}) *gomock.Call { 6948 mr.mock.ctrl.T.Helper() 6949 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsPages), arg0, arg1) 6950 } 6951 6952 // DescribeByoipCidrsPagesWithContext mocks base method 6953 func (m *MockEC2API) DescribeByoipCidrsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeByoipCidrsInput, arg2 func(*ec2.DescribeByoipCidrsOutput, bool) bool, arg3 ...request.Option) error { 6954 m.ctrl.T.Helper() 6955 varargs := []interface{}{arg0, arg1, arg2} 6956 for _, a := range arg3 { 6957 varargs = append(varargs, a) 6958 } 6959 ret := m.ctrl.Call(m, "DescribeByoipCidrsPagesWithContext", varargs...) 6960 ret0, _ := ret[0].(error) 6961 return ret0 6962 } 6963 6964 // DescribeByoipCidrsPagesWithContext indicates an expected call of DescribeByoipCidrsPagesWithContext 6965 func (mr *MockEC2APIMockRecorder) DescribeByoipCidrsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 6966 mr.mock.ctrl.T.Helper() 6967 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 6968 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeByoipCidrsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeByoipCidrsPagesWithContext), varargs...) 6969 } 6970 6971 // DescribeCapacityReservations mocks base method 6972 func (m *MockEC2API) DescribeCapacityReservations(arg0 *ec2.DescribeCapacityReservationsInput) (*ec2.DescribeCapacityReservationsOutput, error) { 6973 m.ctrl.T.Helper() 6974 ret := m.ctrl.Call(m, "DescribeCapacityReservations", arg0) 6975 ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput) 6976 ret1, _ := ret[1].(error) 6977 return ret0, ret1 6978 } 6979 6980 // DescribeCapacityReservations indicates an expected call of DescribeCapacityReservations 6981 func (mr *MockEC2APIMockRecorder) DescribeCapacityReservations(arg0 interface{}) *gomock.Call { 6982 mr.mock.ctrl.T.Helper() 6983 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservations), arg0) 6984 } 6985 6986 // DescribeCapacityReservationsWithContext mocks base method 6987 func (m *MockEC2API) DescribeCapacityReservationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 ...request.Option) (*ec2.DescribeCapacityReservationsOutput, error) { 6988 m.ctrl.T.Helper() 6989 varargs := []interface{}{arg0, arg1} 6990 for _, a := range arg2 { 6991 varargs = append(varargs, a) 6992 } 6993 ret := m.ctrl.Call(m, "DescribeCapacityReservationsWithContext", varargs...) 6994 ret0, _ := ret[0].(*ec2.DescribeCapacityReservationsOutput) 6995 ret1, _ := ret[1].(error) 6996 return ret0, ret1 6997 } 6998 6999 // DescribeCapacityReservationsWithContext indicates an expected call of DescribeCapacityReservationsWithContext 7000 func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7001 mr.mock.ctrl.T.Helper() 7002 varargs := append([]interface{}{arg0, arg1}, arg2...) 7003 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsWithContext), varargs...) 7004 } 7005 7006 // DescribeCapacityReservationsRequest mocks base method 7007 func (m *MockEC2API) DescribeCapacityReservationsRequest(arg0 *ec2.DescribeCapacityReservationsInput) (*request.Request, *ec2.DescribeCapacityReservationsOutput) { 7008 m.ctrl.T.Helper() 7009 ret := m.ctrl.Call(m, "DescribeCapacityReservationsRequest", arg0) 7010 ret0, _ := ret[0].(*request.Request) 7011 ret1, _ := ret[1].(*ec2.DescribeCapacityReservationsOutput) 7012 return ret0, ret1 7013 } 7014 7015 // DescribeCapacityReservationsRequest indicates an expected call of DescribeCapacityReservationsRequest 7016 func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsRequest(arg0 interface{}) *gomock.Call { 7017 mr.mock.ctrl.T.Helper() 7018 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsRequest), arg0) 7019 } 7020 7021 // DescribeCapacityReservationsPages mocks base method 7022 func (m *MockEC2API) DescribeCapacityReservationsPages(arg0 *ec2.DescribeCapacityReservationsInput, arg1 func(*ec2.DescribeCapacityReservationsOutput, bool) bool) error { 7023 m.ctrl.T.Helper() 7024 ret := m.ctrl.Call(m, "DescribeCapacityReservationsPages", arg0, arg1) 7025 ret0, _ := ret[0].(error) 7026 return ret0 7027 } 7028 7029 // DescribeCapacityReservationsPages indicates an expected call of DescribeCapacityReservationsPages 7030 func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsPages(arg0, arg1 interface{}) *gomock.Call { 7031 mr.mock.ctrl.T.Helper() 7032 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsPages), arg0, arg1) 7033 } 7034 7035 // DescribeCapacityReservationsPagesWithContext mocks base method 7036 func (m *MockEC2API) DescribeCapacityReservationsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeCapacityReservationsInput, arg2 func(*ec2.DescribeCapacityReservationsOutput, bool) bool, arg3 ...request.Option) error { 7037 m.ctrl.T.Helper() 7038 varargs := []interface{}{arg0, arg1, arg2} 7039 for _, a := range arg3 { 7040 varargs = append(varargs, a) 7041 } 7042 ret := m.ctrl.Call(m, "DescribeCapacityReservationsPagesWithContext", varargs...) 7043 ret0, _ := ret[0].(error) 7044 return ret0 7045 } 7046 7047 // DescribeCapacityReservationsPagesWithContext indicates an expected call of DescribeCapacityReservationsPagesWithContext 7048 func (mr *MockEC2APIMockRecorder) DescribeCapacityReservationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7049 mr.mock.ctrl.T.Helper() 7050 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7051 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCapacityReservationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCapacityReservationsPagesWithContext), varargs...) 7052 } 7053 7054 // DescribeClassicLinkInstances mocks base method 7055 func (m *MockEC2API) DescribeClassicLinkInstances(arg0 *ec2.DescribeClassicLinkInstancesInput) (*ec2.DescribeClassicLinkInstancesOutput, error) { 7056 m.ctrl.T.Helper() 7057 ret := m.ctrl.Call(m, "DescribeClassicLinkInstances", arg0) 7058 ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput) 7059 ret1, _ := ret[1].(error) 7060 return ret0, ret1 7061 } 7062 7063 // DescribeClassicLinkInstances indicates an expected call of DescribeClassicLinkInstances 7064 func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstances(arg0 interface{}) *gomock.Call { 7065 mr.mock.ctrl.T.Helper() 7066 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstances), arg0) 7067 } 7068 7069 // DescribeClassicLinkInstancesWithContext mocks base method 7070 func (m *MockEC2API) DescribeClassicLinkInstancesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 ...request.Option) (*ec2.DescribeClassicLinkInstancesOutput, error) { 7071 m.ctrl.T.Helper() 7072 varargs := []interface{}{arg0, arg1} 7073 for _, a := range arg2 { 7074 varargs = append(varargs, a) 7075 } 7076 ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesWithContext", varargs...) 7077 ret0, _ := ret[0].(*ec2.DescribeClassicLinkInstancesOutput) 7078 ret1, _ := ret[1].(error) 7079 return ret0, ret1 7080 } 7081 7082 // DescribeClassicLinkInstancesWithContext indicates an expected call of DescribeClassicLinkInstancesWithContext 7083 func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7084 mr.mock.ctrl.T.Helper() 7085 varargs := append([]interface{}{arg0, arg1}, arg2...) 7086 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesWithContext), varargs...) 7087 } 7088 7089 // DescribeClassicLinkInstancesRequest mocks base method 7090 func (m *MockEC2API) DescribeClassicLinkInstancesRequest(arg0 *ec2.DescribeClassicLinkInstancesInput) (*request.Request, *ec2.DescribeClassicLinkInstancesOutput) { 7091 m.ctrl.T.Helper() 7092 ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesRequest", arg0) 7093 ret0, _ := ret[0].(*request.Request) 7094 ret1, _ := ret[1].(*ec2.DescribeClassicLinkInstancesOutput) 7095 return ret0, ret1 7096 } 7097 7098 // DescribeClassicLinkInstancesRequest indicates an expected call of DescribeClassicLinkInstancesRequest 7099 func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesRequest(arg0 interface{}) *gomock.Call { 7100 mr.mock.ctrl.T.Helper() 7101 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesRequest), arg0) 7102 } 7103 7104 // DescribeClassicLinkInstancesPages mocks base method 7105 func (m *MockEC2API) DescribeClassicLinkInstancesPages(arg0 *ec2.DescribeClassicLinkInstancesInput, arg1 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool) error { 7106 m.ctrl.T.Helper() 7107 ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesPages", arg0, arg1) 7108 ret0, _ := ret[0].(error) 7109 return ret0 7110 } 7111 7112 // DescribeClassicLinkInstancesPages indicates an expected call of DescribeClassicLinkInstancesPages 7113 func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesPages(arg0, arg1 interface{}) *gomock.Call { 7114 mr.mock.ctrl.T.Helper() 7115 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesPages), arg0, arg1) 7116 } 7117 7118 // DescribeClassicLinkInstancesPagesWithContext mocks base method 7119 func (m *MockEC2API) DescribeClassicLinkInstancesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClassicLinkInstancesInput, arg2 func(*ec2.DescribeClassicLinkInstancesOutput, bool) bool, arg3 ...request.Option) error { 7120 m.ctrl.T.Helper() 7121 varargs := []interface{}{arg0, arg1, arg2} 7122 for _, a := range arg3 { 7123 varargs = append(varargs, a) 7124 } 7125 ret := m.ctrl.Call(m, "DescribeClassicLinkInstancesPagesWithContext", varargs...) 7126 ret0, _ := ret[0].(error) 7127 return ret0 7128 } 7129 7130 // DescribeClassicLinkInstancesPagesWithContext indicates an expected call of DescribeClassicLinkInstancesPagesWithContext 7131 func (mr *MockEC2APIMockRecorder) DescribeClassicLinkInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7132 mr.mock.ctrl.T.Helper() 7133 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7134 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClassicLinkInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClassicLinkInstancesPagesWithContext), varargs...) 7135 } 7136 7137 // DescribeClientVpnAuthorizationRules mocks base method 7138 func (m *MockEC2API) DescribeClientVpnAuthorizationRules(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) { 7139 m.ctrl.T.Helper() 7140 ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRules", arg0) 7141 ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput) 7142 ret1, _ := ret[1].(error) 7143 return ret0, ret1 7144 } 7145 7146 // DescribeClientVpnAuthorizationRules indicates an expected call of DescribeClientVpnAuthorizationRules 7147 func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRules(arg0 interface{}) *gomock.Call { 7148 mr.mock.ctrl.T.Helper() 7149 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRules", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRules), arg0) 7150 } 7151 7152 // DescribeClientVpnAuthorizationRulesWithContext mocks base method 7153 func (m *MockEC2API) DescribeClientVpnAuthorizationRulesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnAuthorizationRulesOutput, error) { 7154 m.ctrl.T.Helper() 7155 varargs := []interface{}{arg0, arg1} 7156 for _, a := range arg2 { 7157 varargs = append(varargs, a) 7158 } 7159 ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesWithContext", varargs...) 7160 ret0, _ := ret[0].(*ec2.DescribeClientVpnAuthorizationRulesOutput) 7161 ret1, _ := ret[1].(error) 7162 return ret0, ret1 7163 } 7164 7165 // DescribeClientVpnAuthorizationRulesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesWithContext 7166 func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7167 mr.mock.ctrl.T.Helper() 7168 varargs := append([]interface{}{arg0, arg1}, arg2...) 7169 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesWithContext), varargs...) 7170 } 7171 7172 // DescribeClientVpnAuthorizationRulesRequest mocks base method 7173 func (m *MockEC2API) DescribeClientVpnAuthorizationRulesRequest(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput) (*request.Request, *ec2.DescribeClientVpnAuthorizationRulesOutput) { 7174 m.ctrl.T.Helper() 7175 ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesRequest", arg0) 7176 ret0, _ := ret[0].(*request.Request) 7177 ret1, _ := ret[1].(*ec2.DescribeClientVpnAuthorizationRulesOutput) 7178 return ret0, ret1 7179 } 7180 7181 // DescribeClientVpnAuthorizationRulesRequest indicates an expected call of DescribeClientVpnAuthorizationRulesRequest 7182 func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesRequest(arg0 interface{}) *gomock.Call { 7183 mr.mock.ctrl.T.Helper() 7184 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesRequest), arg0) 7185 } 7186 7187 // DescribeClientVpnAuthorizationRulesPages mocks base method 7188 func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPages(arg0 *ec2.DescribeClientVpnAuthorizationRulesInput, arg1 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool) error { 7189 m.ctrl.T.Helper() 7190 ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesPages", arg0, arg1) 7191 ret0, _ := ret[0].(error) 7192 return ret0 7193 } 7194 7195 // DescribeClientVpnAuthorizationRulesPages indicates an expected call of DescribeClientVpnAuthorizationRulesPages 7196 func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesPages(arg0, arg1 interface{}) *gomock.Call { 7197 mr.mock.ctrl.T.Helper() 7198 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPages), arg0, arg1) 7199 } 7200 7201 // DescribeClientVpnAuthorizationRulesPagesWithContext mocks base method 7202 func (m *MockEC2API) DescribeClientVpnAuthorizationRulesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnAuthorizationRulesInput, arg2 func(*ec2.DescribeClientVpnAuthorizationRulesOutput, bool) bool, arg3 ...request.Option) error { 7203 m.ctrl.T.Helper() 7204 varargs := []interface{}{arg0, arg1, arg2} 7205 for _, a := range arg3 { 7206 varargs = append(varargs, a) 7207 } 7208 ret := m.ctrl.Call(m, "DescribeClientVpnAuthorizationRulesPagesWithContext", varargs...) 7209 ret0, _ := ret[0].(error) 7210 return ret0 7211 } 7212 7213 // DescribeClientVpnAuthorizationRulesPagesWithContext indicates an expected call of DescribeClientVpnAuthorizationRulesPagesWithContext 7214 func (mr *MockEC2APIMockRecorder) DescribeClientVpnAuthorizationRulesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7215 mr.mock.ctrl.T.Helper() 7216 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7217 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnAuthorizationRulesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnAuthorizationRulesPagesWithContext), varargs...) 7218 } 7219 7220 // DescribeClientVpnConnections mocks base method 7221 func (m *MockEC2API) DescribeClientVpnConnections(arg0 *ec2.DescribeClientVpnConnectionsInput) (*ec2.DescribeClientVpnConnectionsOutput, error) { 7222 m.ctrl.T.Helper() 7223 ret := m.ctrl.Call(m, "DescribeClientVpnConnections", arg0) 7224 ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput) 7225 ret1, _ := ret[1].(error) 7226 return ret0, ret1 7227 } 7228 7229 // DescribeClientVpnConnections indicates an expected call of DescribeClientVpnConnections 7230 func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnections(arg0 interface{}) *gomock.Call { 7231 mr.mock.ctrl.T.Helper() 7232 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnections), arg0) 7233 } 7234 7235 // DescribeClientVpnConnectionsWithContext mocks base method 7236 func (m *MockEC2API) DescribeClientVpnConnectionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnConnectionsOutput, error) { 7237 m.ctrl.T.Helper() 7238 varargs := []interface{}{arg0, arg1} 7239 for _, a := range arg2 { 7240 varargs = append(varargs, a) 7241 } 7242 ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsWithContext", varargs...) 7243 ret0, _ := ret[0].(*ec2.DescribeClientVpnConnectionsOutput) 7244 ret1, _ := ret[1].(error) 7245 return ret0, ret1 7246 } 7247 7248 // DescribeClientVpnConnectionsWithContext indicates an expected call of DescribeClientVpnConnectionsWithContext 7249 func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7250 mr.mock.ctrl.T.Helper() 7251 varargs := append([]interface{}{arg0, arg1}, arg2...) 7252 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsWithContext), varargs...) 7253 } 7254 7255 // DescribeClientVpnConnectionsRequest mocks base method 7256 func (m *MockEC2API) DescribeClientVpnConnectionsRequest(arg0 *ec2.DescribeClientVpnConnectionsInput) (*request.Request, *ec2.DescribeClientVpnConnectionsOutput) { 7257 m.ctrl.T.Helper() 7258 ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsRequest", arg0) 7259 ret0, _ := ret[0].(*request.Request) 7260 ret1, _ := ret[1].(*ec2.DescribeClientVpnConnectionsOutput) 7261 return ret0, ret1 7262 } 7263 7264 // DescribeClientVpnConnectionsRequest indicates an expected call of DescribeClientVpnConnectionsRequest 7265 func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call { 7266 mr.mock.ctrl.T.Helper() 7267 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsRequest), arg0) 7268 } 7269 7270 // DescribeClientVpnConnectionsPages mocks base method 7271 func (m *MockEC2API) DescribeClientVpnConnectionsPages(arg0 *ec2.DescribeClientVpnConnectionsInput, arg1 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool) error { 7272 m.ctrl.T.Helper() 7273 ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPages", arg0, arg1) 7274 ret0, _ := ret[0].(error) 7275 return ret0 7276 } 7277 7278 // DescribeClientVpnConnectionsPages indicates an expected call of DescribeClientVpnConnectionsPages 7279 func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPages(arg0, arg1 interface{}) *gomock.Call { 7280 mr.mock.ctrl.T.Helper() 7281 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPages), arg0, arg1) 7282 } 7283 7284 // DescribeClientVpnConnectionsPagesWithContext mocks base method 7285 func (m *MockEC2API) DescribeClientVpnConnectionsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnConnectionsInput, arg2 func(*ec2.DescribeClientVpnConnectionsOutput, bool) bool, arg3 ...request.Option) error { 7286 m.ctrl.T.Helper() 7287 varargs := []interface{}{arg0, arg1, arg2} 7288 for _, a := range arg3 { 7289 varargs = append(varargs, a) 7290 } 7291 ret := m.ctrl.Call(m, "DescribeClientVpnConnectionsPagesWithContext", varargs...) 7292 ret0, _ := ret[0].(error) 7293 return ret0 7294 } 7295 7296 // DescribeClientVpnConnectionsPagesWithContext indicates an expected call of DescribeClientVpnConnectionsPagesWithContext 7297 func (mr *MockEC2APIMockRecorder) DescribeClientVpnConnectionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7298 mr.mock.ctrl.T.Helper() 7299 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7300 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnConnectionsPagesWithContext), varargs...) 7301 } 7302 7303 // DescribeClientVpnEndpoints mocks base method 7304 func (m *MockEC2API) DescribeClientVpnEndpoints(arg0 *ec2.DescribeClientVpnEndpointsInput) (*ec2.DescribeClientVpnEndpointsOutput, error) { 7305 m.ctrl.T.Helper() 7306 ret := m.ctrl.Call(m, "DescribeClientVpnEndpoints", arg0) 7307 ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput) 7308 ret1, _ := ret[1].(error) 7309 return ret0, ret1 7310 } 7311 7312 // DescribeClientVpnEndpoints indicates an expected call of DescribeClientVpnEndpoints 7313 func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpoints(arg0 interface{}) *gomock.Call { 7314 mr.mock.ctrl.T.Helper() 7315 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpoints), arg0) 7316 } 7317 7318 // DescribeClientVpnEndpointsWithContext mocks base method 7319 func (m *MockEC2API) DescribeClientVpnEndpointsWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 ...request.Option) (*ec2.DescribeClientVpnEndpointsOutput, error) { 7320 m.ctrl.T.Helper() 7321 varargs := []interface{}{arg0, arg1} 7322 for _, a := range arg2 { 7323 varargs = append(varargs, a) 7324 } 7325 ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsWithContext", varargs...) 7326 ret0, _ := ret[0].(*ec2.DescribeClientVpnEndpointsOutput) 7327 ret1, _ := ret[1].(error) 7328 return ret0, ret1 7329 } 7330 7331 // DescribeClientVpnEndpointsWithContext indicates an expected call of DescribeClientVpnEndpointsWithContext 7332 func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7333 mr.mock.ctrl.T.Helper() 7334 varargs := append([]interface{}{arg0, arg1}, arg2...) 7335 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsWithContext), varargs...) 7336 } 7337 7338 // DescribeClientVpnEndpointsRequest mocks base method 7339 func (m *MockEC2API) DescribeClientVpnEndpointsRequest(arg0 *ec2.DescribeClientVpnEndpointsInput) (*request.Request, *ec2.DescribeClientVpnEndpointsOutput) { 7340 m.ctrl.T.Helper() 7341 ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsRequest", arg0) 7342 ret0, _ := ret[0].(*request.Request) 7343 ret1, _ := ret[1].(*ec2.DescribeClientVpnEndpointsOutput) 7344 return ret0, ret1 7345 } 7346 7347 // DescribeClientVpnEndpointsRequest indicates an expected call of DescribeClientVpnEndpointsRequest 7348 func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsRequest(arg0 interface{}) *gomock.Call { 7349 mr.mock.ctrl.T.Helper() 7350 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsRequest), arg0) 7351 } 7352 7353 // DescribeClientVpnEndpointsPages mocks base method 7354 func (m *MockEC2API) DescribeClientVpnEndpointsPages(arg0 *ec2.DescribeClientVpnEndpointsInput, arg1 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool) error { 7355 m.ctrl.T.Helper() 7356 ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsPages", arg0, arg1) 7357 ret0, _ := ret[0].(error) 7358 return ret0 7359 } 7360 7361 // DescribeClientVpnEndpointsPages indicates an expected call of DescribeClientVpnEndpointsPages 7362 func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsPages(arg0, arg1 interface{}) *gomock.Call { 7363 mr.mock.ctrl.T.Helper() 7364 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsPages), arg0, arg1) 7365 } 7366 7367 // DescribeClientVpnEndpointsPagesWithContext mocks base method 7368 func (m *MockEC2API) DescribeClientVpnEndpointsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnEndpointsInput, arg2 func(*ec2.DescribeClientVpnEndpointsOutput, bool) bool, arg3 ...request.Option) error { 7369 m.ctrl.T.Helper() 7370 varargs := []interface{}{arg0, arg1, arg2} 7371 for _, a := range arg3 { 7372 varargs = append(varargs, a) 7373 } 7374 ret := m.ctrl.Call(m, "DescribeClientVpnEndpointsPagesWithContext", varargs...) 7375 ret0, _ := ret[0].(error) 7376 return ret0 7377 } 7378 7379 // DescribeClientVpnEndpointsPagesWithContext indicates an expected call of DescribeClientVpnEndpointsPagesWithContext 7380 func (mr *MockEC2APIMockRecorder) DescribeClientVpnEndpointsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7381 mr.mock.ctrl.T.Helper() 7382 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7383 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnEndpointsPagesWithContext), varargs...) 7384 } 7385 7386 // DescribeClientVpnRoutes mocks base method 7387 func (m *MockEC2API) DescribeClientVpnRoutes(arg0 *ec2.DescribeClientVpnRoutesInput) (*ec2.DescribeClientVpnRoutesOutput, error) { 7388 m.ctrl.T.Helper() 7389 ret := m.ctrl.Call(m, "DescribeClientVpnRoutes", arg0) 7390 ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput) 7391 ret1, _ := ret[1].(error) 7392 return ret0, ret1 7393 } 7394 7395 // DescribeClientVpnRoutes indicates an expected call of DescribeClientVpnRoutes 7396 func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutes(arg0 interface{}) *gomock.Call { 7397 mr.mock.ctrl.T.Helper() 7398 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutes", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutes), arg0) 7399 } 7400 7401 // DescribeClientVpnRoutesWithContext mocks base method 7402 func (m *MockEC2API) DescribeClientVpnRoutesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 ...request.Option) (*ec2.DescribeClientVpnRoutesOutput, error) { 7403 m.ctrl.T.Helper() 7404 varargs := []interface{}{arg0, arg1} 7405 for _, a := range arg2 { 7406 varargs = append(varargs, a) 7407 } 7408 ret := m.ctrl.Call(m, "DescribeClientVpnRoutesWithContext", varargs...) 7409 ret0, _ := ret[0].(*ec2.DescribeClientVpnRoutesOutput) 7410 ret1, _ := ret[1].(error) 7411 return ret0, ret1 7412 } 7413 7414 // DescribeClientVpnRoutesWithContext indicates an expected call of DescribeClientVpnRoutesWithContext 7415 func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7416 mr.mock.ctrl.T.Helper() 7417 varargs := append([]interface{}{arg0, arg1}, arg2...) 7418 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesWithContext), varargs...) 7419 } 7420 7421 // DescribeClientVpnRoutesRequest mocks base method 7422 func (m *MockEC2API) DescribeClientVpnRoutesRequest(arg0 *ec2.DescribeClientVpnRoutesInput) (*request.Request, *ec2.DescribeClientVpnRoutesOutput) { 7423 m.ctrl.T.Helper() 7424 ret := m.ctrl.Call(m, "DescribeClientVpnRoutesRequest", arg0) 7425 ret0, _ := ret[0].(*request.Request) 7426 ret1, _ := ret[1].(*ec2.DescribeClientVpnRoutesOutput) 7427 return ret0, ret1 7428 } 7429 7430 // DescribeClientVpnRoutesRequest indicates an expected call of DescribeClientVpnRoutesRequest 7431 func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesRequest(arg0 interface{}) *gomock.Call { 7432 mr.mock.ctrl.T.Helper() 7433 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesRequest), arg0) 7434 } 7435 7436 // DescribeClientVpnRoutesPages mocks base method 7437 func (m *MockEC2API) DescribeClientVpnRoutesPages(arg0 *ec2.DescribeClientVpnRoutesInput, arg1 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool) error { 7438 m.ctrl.T.Helper() 7439 ret := m.ctrl.Call(m, "DescribeClientVpnRoutesPages", arg0, arg1) 7440 ret0, _ := ret[0].(error) 7441 return ret0 7442 } 7443 7444 // DescribeClientVpnRoutesPages indicates an expected call of DescribeClientVpnRoutesPages 7445 func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesPages(arg0, arg1 interface{}) *gomock.Call { 7446 mr.mock.ctrl.T.Helper() 7447 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesPages), arg0, arg1) 7448 } 7449 7450 // DescribeClientVpnRoutesPagesWithContext mocks base method 7451 func (m *MockEC2API) DescribeClientVpnRoutesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnRoutesInput, arg2 func(*ec2.DescribeClientVpnRoutesOutput, bool) bool, arg3 ...request.Option) error { 7452 m.ctrl.T.Helper() 7453 varargs := []interface{}{arg0, arg1, arg2} 7454 for _, a := range arg3 { 7455 varargs = append(varargs, a) 7456 } 7457 ret := m.ctrl.Call(m, "DescribeClientVpnRoutesPagesWithContext", varargs...) 7458 ret0, _ := ret[0].(error) 7459 return ret0 7460 } 7461 7462 // DescribeClientVpnRoutesPagesWithContext indicates an expected call of DescribeClientVpnRoutesPagesWithContext 7463 func (mr *MockEC2APIMockRecorder) DescribeClientVpnRoutesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7464 mr.mock.ctrl.T.Helper() 7465 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7466 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnRoutesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnRoutesPagesWithContext), varargs...) 7467 } 7468 7469 // DescribeClientVpnTargetNetworks mocks base method 7470 func (m *MockEC2API) DescribeClientVpnTargetNetworks(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*ec2.DescribeClientVpnTargetNetworksOutput, error) { 7471 m.ctrl.T.Helper() 7472 ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworks", arg0) 7473 ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput) 7474 ret1, _ := ret[1].(error) 7475 return ret0, ret1 7476 } 7477 7478 // DescribeClientVpnTargetNetworks indicates an expected call of DescribeClientVpnTargetNetworks 7479 func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworks(arg0 interface{}) *gomock.Call { 7480 mr.mock.ctrl.T.Helper() 7481 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworks", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworks), arg0) 7482 } 7483 7484 // DescribeClientVpnTargetNetworksWithContext mocks base method 7485 func (m *MockEC2API) DescribeClientVpnTargetNetworksWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 ...request.Option) (*ec2.DescribeClientVpnTargetNetworksOutput, error) { 7486 m.ctrl.T.Helper() 7487 varargs := []interface{}{arg0, arg1} 7488 for _, a := range arg2 { 7489 varargs = append(varargs, a) 7490 } 7491 ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksWithContext", varargs...) 7492 ret0, _ := ret[0].(*ec2.DescribeClientVpnTargetNetworksOutput) 7493 ret1, _ := ret[1].(error) 7494 return ret0, ret1 7495 } 7496 7497 // DescribeClientVpnTargetNetworksWithContext indicates an expected call of DescribeClientVpnTargetNetworksWithContext 7498 func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7499 mr.mock.ctrl.T.Helper() 7500 varargs := append([]interface{}{arg0, arg1}, arg2...) 7501 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksWithContext), varargs...) 7502 } 7503 7504 // DescribeClientVpnTargetNetworksRequest mocks base method 7505 func (m *MockEC2API) DescribeClientVpnTargetNetworksRequest(arg0 *ec2.DescribeClientVpnTargetNetworksInput) (*request.Request, *ec2.DescribeClientVpnTargetNetworksOutput) { 7506 m.ctrl.T.Helper() 7507 ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksRequest", arg0) 7508 ret0, _ := ret[0].(*request.Request) 7509 ret1, _ := ret[1].(*ec2.DescribeClientVpnTargetNetworksOutput) 7510 return ret0, ret1 7511 } 7512 7513 // DescribeClientVpnTargetNetworksRequest indicates an expected call of DescribeClientVpnTargetNetworksRequest 7514 func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksRequest(arg0 interface{}) *gomock.Call { 7515 mr.mock.ctrl.T.Helper() 7516 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksRequest), arg0) 7517 } 7518 7519 // DescribeClientVpnTargetNetworksPages mocks base method 7520 func (m *MockEC2API) DescribeClientVpnTargetNetworksPages(arg0 *ec2.DescribeClientVpnTargetNetworksInput, arg1 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool) error { 7521 m.ctrl.T.Helper() 7522 ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksPages", arg0, arg1) 7523 ret0, _ := ret[0].(error) 7524 return ret0 7525 } 7526 7527 // DescribeClientVpnTargetNetworksPages indicates an expected call of DescribeClientVpnTargetNetworksPages 7528 func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksPages(arg0, arg1 interface{}) *gomock.Call { 7529 mr.mock.ctrl.T.Helper() 7530 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPages), arg0, arg1) 7531 } 7532 7533 // DescribeClientVpnTargetNetworksPagesWithContext mocks base method 7534 func (m *MockEC2API) DescribeClientVpnTargetNetworksPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeClientVpnTargetNetworksInput, arg2 func(*ec2.DescribeClientVpnTargetNetworksOutput, bool) bool, arg3 ...request.Option) error { 7535 m.ctrl.T.Helper() 7536 varargs := []interface{}{arg0, arg1, arg2} 7537 for _, a := range arg3 { 7538 varargs = append(varargs, a) 7539 } 7540 ret := m.ctrl.Call(m, "DescribeClientVpnTargetNetworksPagesWithContext", varargs...) 7541 ret0, _ := ret[0].(error) 7542 return ret0 7543 } 7544 7545 // DescribeClientVpnTargetNetworksPagesWithContext indicates an expected call of DescribeClientVpnTargetNetworksPagesWithContext 7546 func (mr *MockEC2APIMockRecorder) DescribeClientVpnTargetNetworksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7547 mr.mock.ctrl.T.Helper() 7548 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7549 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeClientVpnTargetNetworksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeClientVpnTargetNetworksPagesWithContext), varargs...) 7550 } 7551 7552 // DescribeConversionTasks mocks base method 7553 func (m *MockEC2API) DescribeConversionTasks(arg0 *ec2.DescribeConversionTasksInput) (*ec2.DescribeConversionTasksOutput, error) { 7554 m.ctrl.T.Helper() 7555 ret := m.ctrl.Call(m, "DescribeConversionTasks", arg0) 7556 ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput) 7557 ret1, _ := ret[1].(error) 7558 return ret0, ret1 7559 } 7560 7561 // DescribeConversionTasks indicates an expected call of DescribeConversionTasks 7562 func (mr *MockEC2APIMockRecorder) DescribeConversionTasks(arg0 interface{}) *gomock.Call { 7563 mr.mock.ctrl.T.Helper() 7564 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasks), arg0) 7565 } 7566 7567 // DescribeConversionTasksWithContext mocks base method 7568 func (m *MockEC2API) DescribeConversionTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.Option) (*ec2.DescribeConversionTasksOutput, error) { 7569 m.ctrl.T.Helper() 7570 varargs := []interface{}{arg0, arg1} 7571 for _, a := range arg2 { 7572 varargs = append(varargs, a) 7573 } 7574 ret := m.ctrl.Call(m, "DescribeConversionTasksWithContext", varargs...) 7575 ret0, _ := ret[0].(*ec2.DescribeConversionTasksOutput) 7576 ret1, _ := ret[1].(error) 7577 return ret0, ret1 7578 } 7579 7580 // DescribeConversionTasksWithContext indicates an expected call of DescribeConversionTasksWithContext 7581 func (mr *MockEC2APIMockRecorder) DescribeConversionTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7582 mr.mock.ctrl.T.Helper() 7583 varargs := append([]interface{}{arg0, arg1}, arg2...) 7584 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksWithContext), varargs...) 7585 } 7586 7587 // DescribeConversionTasksRequest mocks base method 7588 func (m *MockEC2API) DescribeConversionTasksRequest(arg0 *ec2.DescribeConversionTasksInput) (*request.Request, *ec2.DescribeConversionTasksOutput) { 7589 m.ctrl.T.Helper() 7590 ret := m.ctrl.Call(m, "DescribeConversionTasksRequest", arg0) 7591 ret0, _ := ret[0].(*request.Request) 7592 ret1, _ := ret[1].(*ec2.DescribeConversionTasksOutput) 7593 return ret0, ret1 7594 } 7595 7596 // DescribeConversionTasksRequest indicates an expected call of DescribeConversionTasksRequest 7597 func (mr *MockEC2APIMockRecorder) DescribeConversionTasksRequest(arg0 interface{}) *gomock.Call { 7598 mr.mock.ctrl.T.Helper() 7599 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeConversionTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeConversionTasksRequest), arg0) 7600 } 7601 7602 // DescribeCustomerGateways mocks base method 7603 func (m *MockEC2API) DescribeCustomerGateways(arg0 *ec2.DescribeCustomerGatewaysInput) (*ec2.DescribeCustomerGatewaysOutput, error) { 7604 m.ctrl.T.Helper() 7605 ret := m.ctrl.Call(m, "DescribeCustomerGateways", arg0) 7606 ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput) 7607 ret1, _ := ret[1].(error) 7608 return ret0, ret1 7609 } 7610 7611 // DescribeCustomerGateways indicates an expected call of DescribeCustomerGateways 7612 func (mr *MockEC2APIMockRecorder) DescribeCustomerGateways(arg0 interface{}) *gomock.Call { 7613 mr.mock.ctrl.T.Helper() 7614 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGateways), arg0) 7615 } 7616 7617 // DescribeCustomerGatewaysWithContext mocks base method 7618 func (m *MockEC2API) DescribeCustomerGatewaysWithContext(arg0 aws.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.Option) (*ec2.DescribeCustomerGatewaysOutput, error) { 7619 m.ctrl.T.Helper() 7620 varargs := []interface{}{arg0, arg1} 7621 for _, a := range arg2 { 7622 varargs = append(varargs, a) 7623 } 7624 ret := m.ctrl.Call(m, "DescribeCustomerGatewaysWithContext", varargs...) 7625 ret0, _ := ret[0].(*ec2.DescribeCustomerGatewaysOutput) 7626 ret1, _ := ret[1].(error) 7627 return ret0, ret1 7628 } 7629 7630 // DescribeCustomerGatewaysWithContext indicates an expected call of DescribeCustomerGatewaysWithContext 7631 func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7632 mr.mock.ctrl.T.Helper() 7633 varargs := append([]interface{}{arg0, arg1}, arg2...) 7634 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysWithContext), varargs...) 7635 } 7636 7637 // DescribeCustomerGatewaysRequest mocks base method 7638 func (m *MockEC2API) DescribeCustomerGatewaysRequest(arg0 *ec2.DescribeCustomerGatewaysInput) (*request.Request, *ec2.DescribeCustomerGatewaysOutput) { 7639 m.ctrl.T.Helper() 7640 ret := m.ctrl.Call(m, "DescribeCustomerGatewaysRequest", arg0) 7641 ret0, _ := ret[0].(*request.Request) 7642 ret1, _ := ret[1].(*ec2.DescribeCustomerGatewaysOutput) 7643 return ret0, ret1 7644 } 7645 7646 // DescribeCustomerGatewaysRequest indicates an expected call of DescribeCustomerGatewaysRequest 7647 func (mr *MockEC2APIMockRecorder) DescribeCustomerGatewaysRequest(arg0 interface{}) *gomock.Call { 7648 mr.mock.ctrl.T.Helper() 7649 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeCustomerGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeCustomerGatewaysRequest), arg0) 7650 } 7651 7652 // DescribeDhcpOptions mocks base method 7653 func (m *MockEC2API) DescribeDhcpOptions(arg0 *ec2.DescribeDhcpOptionsInput) (*ec2.DescribeDhcpOptionsOutput, error) { 7654 m.ctrl.T.Helper() 7655 ret := m.ctrl.Call(m, "DescribeDhcpOptions", arg0) 7656 ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput) 7657 ret1, _ := ret[1].(error) 7658 return ret0, ret1 7659 } 7660 7661 // DescribeDhcpOptions indicates an expected call of DescribeDhcpOptions 7662 func (mr *MockEC2APIMockRecorder) DescribeDhcpOptions(arg0 interface{}) *gomock.Call { 7663 mr.mock.ctrl.T.Helper() 7664 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptions", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptions), arg0) 7665 } 7666 7667 // DescribeDhcpOptionsWithContext mocks base method 7668 func (m *MockEC2API) DescribeDhcpOptionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 ...request.Option) (*ec2.DescribeDhcpOptionsOutput, error) { 7669 m.ctrl.T.Helper() 7670 varargs := []interface{}{arg0, arg1} 7671 for _, a := range arg2 { 7672 varargs = append(varargs, a) 7673 } 7674 ret := m.ctrl.Call(m, "DescribeDhcpOptionsWithContext", varargs...) 7675 ret0, _ := ret[0].(*ec2.DescribeDhcpOptionsOutput) 7676 ret1, _ := ret[1].(error) 7677 return ret0, ret1 7678 } 7679 7680 // DescribeDhcpOptionsWithContext indicates an expected call of DescribeDhcpOptionsWithContext 7681 func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7682 mr.mock.ctrl.T.Helper() 7683 varargs := append([]interface{}{arg0, arg1}, arg2...) 7684 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsWithContext), varargs...) 7685 } 7686 7687 // DescribeDhcpOptionsRequest mocks base method 7688 func (m *MockEC2API) DescribeDhcpOptionsRequest(arg0 *ec2.DescribeDhcpOptionsInput) (*request.Request, *ec2.DescribeDhcpOptionsOutput) { 7689 m.ctrl.T.Helper() 7690 ret := m.ctrl.Call(m, "DescribeDhcpOptionsRequest", arg0) 7691 ret0, _ := ret[0].(*request.Request) 7692 ret1, _ := ret[1].(*ec2.DescribeDhcpOptionsOutput) 7693 return ret0, ret1 7694 } 7695 7696 // DescribeDhcpOptionsRequest indicates an expected call of DescribeDhcpOptionsRequest 7697 func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsRequest(arg0 interface{}) *gomock.Call { 7698 mr.mock.ctrl.T.Helper() 7699 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsRequest), arg0) 7700 } 7701 7702 // DescribeDhcpOptionsPages mocks base method 7703 func (m *MockEC2API) DescribeDhcpOptionsPages(arg0 *ec2.DescribeDhcpOptionsInput, arg1 func(*ec2.DescribeDhcpOptionsOutput, bool) bool) error { 7704 m.ctrl.T.Helper() 7705 ret := m.ctrl.Call(m, "DescribeDhcpOptionsPages", arg0, arg1) 7706 ret0, _ := ret[0].(error) 7707 return ret0 7708 } 7709 7710 // DescribeDhcpOptionsPages indicates an expected call of DescribeDhcpOptionsPages 7711 func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsPages(arg0, arg1 interface{}) *gomock.Call { 7712 mr.mock.ctrl.T.Helper() 7713 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsPages), arg0, arg1) 7714 } 7715 7716 // DescribeDhcpOptionsPagesWithContext mocks base method 7717 func (m *MockEC2API) DescribeDhcpOptionsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeDhcpOptionsInput, arg2 func(*ec2.DescribeDhcpOptionsOutput, bool) bool, arg3 ...request.Option) error { 7718 m.ctrl.T.Helper() 7719 varargs := []interface{}{arg0, arg1, arg2} 7720 for _, a := range arg3 { 7721 varargs = append(varargs, a) 7722 } 7723 ret := m.ctrl.Call(m, "DescribeDhcpOptionsPagesWithContext", varargs...) 7724 ret0, _ := ret[0].(error) 7725 return ret0 7726 } 7727 7728 // DescribeDhcpOptionsPagesWithContext indicates an expected call of DescribeDhcpOptionsPagesWithContext 7729 func (mr *MockEC2APIMockRecorder) DescribeDhcpOptionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7730 mr.mock.ctrl.T.Helper() 7731 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7732 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeDhcpOptionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeDhcpOptionsPagesWithContext), varargs...) 7733 } 7734 7735 // DescribeEgressOnlyInternetGateways mocks base method 7736 func (m *MockEC2API) DescribeEgressOnlyInternetGateways(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) { 7737 m.ctrl.T.Helper() 7738 ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGateways", arg0) 7739 ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) 7740 ret1, _ := ret[1].(error) 7741 return ret0, ret1 7742 } 7743 7744 // DescribeEgressOnlyInternetGateways indicates an expected call of DescribeEgressOnlyInternetGateways 7745 func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGateways(arg0 interface{}) *gomock.Call { 7746 mr.mock.ctrl.T.Helper() 7747 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGateways), arg0) 7748 } 7749 7750 // DescribeEgressOnlyInternetGatewaysWithContext mocks base method 7751 func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysWithContext(arg0 aws.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeEgressOnlyInternetGatewaysOutput, error) { 7752 m.ctrl.T.Helper() 7753 varargs := []interface{}{arg0, arg1} 7754 for _, a := range arg2 { 7755 varargs = append(varargs, a) 7756 } 7757 ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysWithContext", varargs...) 7758 ret0, _ := ret[0].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) 7759 ret1, _ := ret[1].(error) 7760 return ret0, ret1 7761 } 7762 7763 // DescribeEgressOnlyInternetGatewaysWithContext indicates an expected call of DescribeEgressOnlyInternetGatewaysWithContext 7764 func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7765 mr.mock.ctrl.T.Helper() 7766 varargs := append([]interface{}{arg0, arg1}, arg2...) 7767 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysWithContext), varargs...) 7768 } 7769 7770 // DescribeEgressOnlyInternetGatewaysRequest mocks base method 7771 func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysRequest(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput) (*request.Request, *ec2.DescribeEgressOnlyInternetGatewaysOutput) { 7772 m.ctrl.T.Helper() 7773 ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysRequest", arg0) 7774 ret0, _ := ret[0].(*request.Request) 7775 ret1, _ := ret[1].(*ec2.DescribeEgressOnlyInternetGatewaysOutput) 7776 return ret0, ret1 7777 } 7778 7779 // DescribeEgressOnlyInternetGatewaysRequest indicates an expected call of DescribeEgressOnlyInternetGatewaysRequest 7780 func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysRequest(arg0 interface{}) *gomock.Call { 7781 mr.mock.ctrl.T.Helper() 7782 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysRequest), arg0) 7783 } 7784 7785 // DescribeEgressOnlyInternetGatewaysPages mocks base method 7786 func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPages(arg0 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg1 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool) error { 7787 m.ctrl.T.Helper() 7788 ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysPages", arg0, arg1) 7789 ret0, _ := ret[0].(error) 7790 return ret0 7791 } 7792 7793 // DescribeEgressOnlyInternetGatewaysPages indicates an expected call of DescribeEgressOnlyInternetGatewaysPages 7794 func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call { 7795 mr.mock.ctrl.T.Helper() 7796 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPages), arg0, arg1) 7797 } 7798 7799 // DescribeEgressOnlyInternetGatewaysPagesWithContext mocks base method 7800 func (m *MockEC2API) DescribeEgressOnlyInternetGatewaysPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeEgressOnlyInternetGatewaysInput, arg2 func(*ec2.DescribeEgressOnlyInternetGatewaysOutput, bool) bool, arg3 ...request.Option) error { 7801 m.ctrl.T.Helper() 7802 varargs := []interface{}{arg0, arg1, arg2} 7803 for _, a := range arg3 { 7804 varargs = append(varargs, a) 7805 } 7806 ret := m.ctrl.Call(m, "DescribeEgressOnlyInternetGatewaysPagesWithContext", varargs...) 7807 ret0, _ := ret[0].(error) 7808 return ret0 7809 } 7810 7811 // DescribeEgressOnlyInternetGatewaysPagesWithContext indicates an expected call of DescribeEgressOnlyInternetGatewaysPagesWithContext 7812 func (mr *MockEC2APIMockRecorder) DescribeEgressOnlyInternetGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 7813 mr.mock.ctrl.T.Helper() 7814 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 7815 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeEgressOnlyInternetGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeEgressOnlyInternetGatewaysPagesWithContext), varargs...) 7816 } 7817 7818 // DescribeElasticGpus mocks base method 7819 func (m *MockEC2API) DescribeElasticGpus(arg0 *ec2.DescribeElasticGpusInput) (*ec2.DescribeElasticGpusOutput, error) { 7820 m.ctrl.T.Helper() 7821 ret := m.ctrl.Call(m, "DescribeElasticGpus", arg0) 7822 ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput) 7823 ret1, _ := ret[1].(error) 7824 return ret0, ret1 7825 } 7826 7827 // DescribeElasticGpus indicates an expected call of DescribeElasticGpus 7828 func (mr *MockEC2APIMockRecorder) DescribeElasticGpus(arg0 interface{}) *gomock.Call { 7829 mr.mock.ctrl.T.Helper() 7830 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpus", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpus), arg0) 7831 } 7832 7833 // DescribeElasticGpusWithContext mocks base method 7834 func (m *MockEC2API) DescribeElasticGpusWithContext(arg0 aws.Context, arg1 *ec2.DescribeElasticGpusInput, arg2 ...request.Option) (*ec2.DescribeElasticGpusOutput, error) { 7835 m.ctrl.T.Helper() 7836 varargs := []interface{}{arg0, arg1} 7837 for _, a := range arg2 { 7838 varargs = append(varargs, a) 7839 } 7840 ret := m.ctrl.Call(m, "DescribeElasticGpusWithContext", varargs...) 7841 ret0, _ := ret[0].(*ec2.DescribeElasticGpusOutput) 7842 ret1, _ := ret[1].(error) 7843 return ret0, ret1 7844 } 7845 7846 // DescribeElasticGpusWithContext indicates an expected call of DescribeElasticGpusWithContext 7847 func (mr *MockEC2APIMockRecorder) DescribeElasticGpusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7848 mr.mock.ctrl.T.Helper() 7849 varargs := append([]interface{}{arg0, arg1}, arg2...) 7850 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpusWithContext), varargs...) 7851 } 7852 7853 // DescribeElasticGpusRequest mocks base method 7854 func (m *MockEC2API) DescribeElasticGpusRequest(arg0 *ec2.DescribeElasticGpusInput) (*request.Request, *ec2.DescribeElasticGpusOutput) { 7855 m.ctrl.T.Helper() 7856 ret := m.ctrl.Call(m, "DescribeElasticGpusRequest", arg0) 7857 ret0, _ := ret[0].(*request.Request) 7858 ret1, _ := ret[1].(*ec2.DescribeElasticGpusOutput) 7859 return ret0, ret1 7860 } 7861 7862 // DescribeElasticGpusRequest indicates an expected call of DescribeElasticGpusRequest 7863 func (mr *MockEC2APIMockRecorder) DescribeElasticGpusRequest(arg0 interface{}) *gomock.Call { 7864 mr.mock.ctrl.T.Helper() 7865 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeElasticGpusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeElasticGpusRequest), arg0) 7866 } 7867 7868 // DescribeExportImageTasks mocks base method 7869 func (m *MockEC2API) DescribeExportImageTasks(arg0 *ec2.DescribeExportImageTasksInput) (*ec2.DescribeExportImageTasksOutput, error) { 7870 m.ctrl.T.Helper() 7871 ret := m.ctrl.Call(m, "DescribeExportImageTasks", arg0) 7872 ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput) 7873 ret1, _ := ret[1].(error) 7874 return ret0, ret1 7875 } 7876 7877 // DescribeExportImageTasks indicates an expected call of DescribeExportImageTasks 7878 func (mr *MockEC2APIMockRecorder) DescribeExportImageTasks(arg0 interface{}) *gomock.Call { 7879 mr.mock.ctrl.T.Helper() 7880 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasks), arg0) 7881 } 7882 7883 // DescribeExportImageTasksWithContext mocks base method 7884 func (m *MockEC2API) DescribeExportImageTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeExportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeExportImageTasksOutput, error) { 7885 m.ctrl.T.Helper() 7886 varargs := []interface{}{arg0, arg1} 7887 for _, a := range arg2 { 7888 varargs = append(varargs, a) 7889 } 7890 ret := m.ctrl.Call(m, "DescribeExportImageTasksWithContext", varargs...) 7891 ret0, _ := ret[0].(*ec2.DescribeExportImageTasksOutput) 7892 ret1, _ := ret[1].(error) 7893 return ret0, ret1 7894 } 7895 7896 // DescribeExportImageTasksWithContext indicates an expected call of DescribeExportImageTasksWithContext 7897 func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7898 mr.mock.ctrl.T.Helper() 7899 varargs := append([]interface{}{arg0, arg1}, arg2...) 7900 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksWithContext), varargs...) 7901 } 7902 7903 // DescribeExportImageTasksRequest mocks base method 7904 func (m *MockEC2API) DescribeExportImageTasksRequest(arg0 *ec2.DescribeExportImageTasksInput) (*request.Request, *ec2.DescribeExportImageTasksOutput) { 7905 m.ctrl.T.Helper() 7906 ret := m.ctrl.Call(m, "DescribeExportImageTasksRequest", arg0) 7907 ret0, _ := ret[0].(*request.Request) 7908 ret1, _ := ret[1].(*ec2.DescribeExportImageTasksOutput) 7909 return ret0, ret1 7910 } 7911 7912 // DescribeExportImageTasksRequest indicates an expected call of DescribeExportImageTasksRequest 7913 func (mr *MockEC2APIMockRecorder) DescribeExportImageTasksRequest(arg0 interface{}) *gomock.Call { 7914 mr.mock.ctrl.T.Helper() 7915 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportImageTasksRequest), arg0) 7916 } 7917 7918 // DescribeExportTasks mocks base method 7919 func (m *MockEC2API) DescribeExportTasks(arg0 *ec2.DescribeExportTasksInput) (*ec2.DescribeExportTasksOutput, error) { 7920 m.ctrl.T.Helper() 7921 ret := m.ctrl.Call(m, "DescribeExportTasks", arg0) 7922 ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput) 7923 ret1, _ := ret[1].(error) 7924 return ret0, ret1 7925 } 7926 7927 // DescribeExportTasks indicates an expected call of DescribeExportTasks 7928 func (mr *MockEC2APIMockRecorder) DescribeExportTasks(arg0 interface{}) *gomock.Call { 7929 mr.mock.ctrl.T.Helper() 7930 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasks), arg0) 7931 } 7932 7933 // DescribeExportTasksWithContext mocks base method 7934 func (m *MockEC2API) DescribeExportTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.Option) (*ec2.DescribeExportTasksOutput, error) { 7935 m.ctrl.T.Helper() 7936 varargs := []interface{}{arg0, arg1} 7937 for _, a := range arg2 { 7938 varargs = append(varargs, a) 7939 } 7940 ret := m.ctrl.Call(m, "DescribeExportTasksWithContext", varargs...) 7941 ret0, _ := ret[0].(*ec2.DescribeExportTasksOutput) 7942 ret1, _ := ret[1].(error) 7943 return ret0, ret1 7944 } 7945 7946 // DescribeExportTasksWithContext indicates an expected call of DescribeExportTasksWithContext 7947 func (mr *MockEC2APIMockRecorder) DescribeExportTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7948 mr.mock.ctrl.T.Helper() 7949 varargs := append([]interface{}{arg0, arg1}, arg2...) 7950 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasksWithContext), varargs...) 7951 } 7952 7953 // DescribeExportTasksRequest mocks base method 7954 func (m *MockEC2API) DescribeExportTasksRequest(arg0 *ec2.DescribeExportTasksInput) (*request.Request, *ec2.DescribeExportTasksOutput) { 7955 m.ctrl.T.Helper() 7956 ret := m.ctrl.Call(m, "DescribeExportTasksRequest", arg0) 7957 ret0, _ := ret[0].(*request.Request) 7958 ret1, _ := ret[1].(*ec2.DescribeExportTasksOutput) 7959 return ret0, ret1 7960 } 7961 7962 // DescribeExportTasksRequest indicates an expected call of DescribeExportTasksRequest 7963 func (mr *MockEC2APIMockRecorder) DescribeExportTasksRequest(arg0 interface{}) *gomock.Call { 7964 mr.mock.ctrl.T.Helper() 7965 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeExportTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeExportTasksRequest), arg0) 7966 } 7967 7968 // DescribeFleetHistory mocks base method 7969 func (m *MockEC2API) DescribeFleetHistory(arg0 *ec2.DescribeFleetHistoryInput) (*ec2.DescribeFleetHistoryOutput, error) { 7970 m.ctrl.T.Helper() 7971 ret := m.ctrl.Call(m, "DescribeFleetHistory", arg0) 7972 ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput) 7973 ret1, _ := ret[1].(error) 7974 return ret0, ret1 7975 } 7976 7977 // DescribeFleetHistory indicates an expected call of DescribeFleetHistory 7978 func (mr *MockEC2APIMockRecorder) DescribeFleetHistory(arg0 interface{}) *gomock.Call { 7979 mr.mock.ctrl.T.Helper() 7980 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistory), arg0) 7981 } 7982 7983 // DescribeFleetHistoryWithContext mocks base method 7984 func (m *MockEC2API) DescribeFleetHistoryWithContext(arg0 aws.Context, arg1 *ec2.DescribeFleetHistoryInput, arg2 ...request.Option) (*ec2.DescribeFleetHistoryOutput, error) { 7985 m.ctrl.T.Helper() 7986 varargs := []interface{}{arg0, arg1} 7987 for _, a := range arg2 { 7988 varargs = append(varargs, a) 7989 } 7990 ret := m.ctrl.Call(m, "DescribeFleetHistoryWithContext", varargs...) 7991 ret0, _ := ret[0].(*ec2.DescribeFleetHistoryOutput) 7992 ret1, _ := ret[1].(error) 7993 return ret0, ret1 7994 } 7995 7996 // DescribeFleetHistoryWithContext indicates an expected call of DescribeFleetHistoryWithContext 7997 func (mr *MockEC2APIMockRecorder) DescribeFleetHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 7998 mr.mock.ctrl.T.Helper() 7999 varargs := append([]interface{}{arg0, arg1}, arg2...) 8000 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistoryWithContext), varargs...) 8001 } 8002 8003 // DescribeFleetHistoryRequest mocks base method 8004 func (m *MockEC2API) DescribeFleetHistoryRequest(arg0 *ec2.DescribeFleetHistoryInput) (*request.Request, *ec2.DescribeFleetHistoryOutput) { 8005 m.ctrl.T.Helper() 8006 ret := m.ctrl.Call(m, "DescribeFleetHistoryRequest", arg0) 8007 ret0, _ := ret[0].(*request.Request) 8008 ret1, _ := ret[1].(*ec2.DescribeFleetHistoryOutput) 8009 return ret0, ret1 8010 } 8011 8012 // DescribeFleetHistoryRequest indicates an expected call of DescribeFleetHistoryRequest 8013 func (mr *MockEC2APIMockRecorder) DescribeFleetHistoryRequest(arg0 interface{}) *gomock.Call { 8014 mr.mock.ctrl.T.Helper() 8015 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetHistoryRequest), arg0) 8016 } 8017 8018 // DescribeFleetInstances mocks base method 8019 func (m *MockEC2API) DescribeFleetInstances(arg0 *ec2.DescribeFleetInstancesInput) (*ec2.DescribeFleetInstancesOutput, error) { 8020 m.ctrl.T.Helper() 8021 ret := m.ctrl.Call(m, "DescribeFleetInstances", arg0) 8022 ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput) 8023 ret1, _ := ret[1].(error) 8024 return ret0, ret1 8025 } 8026 8027 // DescribeFleetInstances indicates an expected call of DescribeFleetInstances 8028 func (mr *MockEC2APIMockRecorder) DescribeFleetInstances(arg0 interface{}) *gomock.Call { 8029 mr.mock.ctrl.T.Helper() 8030 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstances), arg0) 8031 } 8032 8033 // DescribeFleetInstancesWithContext mocks base method 8034 func (m *MockEC2API) DescribeFleetInstancesWithContext(arg0 aws.Context, arg1 *ec2.DescribeFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeFleetInstancesOutput, error) { 8035 m.ctrl.T.Helper() 8036 varargs := []interface{}{arg0, arg1} 8037 for _, a := range arg2 { 8038 varargs = append(varargs, a) 8039 } 8040 ret := m.ctrl.Call(m, "DescribeFleetInstancesWithContext", varargs...) 8041 ret0, _ := ret[0].(*ec2.DescribeFleetInstancesOutput) 8042 ret1, _ := ret[1].(error) 8043 return ret0, ret1 8044 } 8045 8046 // DescribeFleetInstancesWithContext indicates an expected call of DescribeFleetInstancesWithContext 8047 func (mr *MockEC2APIMockRecorder) DescribeFleetInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8048 mr.mock.ctrl.T.Helper() 8049 varargs := append([]interface{}{arg0, arg1}, arg2...) 8050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstancesWithContext), varargs...) 8051 } 8052 8053 // DescribeFleetInstancesRequest mocks base method 8054 func (m *MockEC2API) DescribeFleetInstancesRequest(arg0 *ec2.DescribeFleetInstancesInput) (*request.Request, *ec2.DescribeFleetInstancesOutput) { 8055 m.ctrl.T.Helper() 8056 ret := m.ctrl.Call(m, "DescribeFleetInstancesRequest", arg0) 8057 ret0, _ := ret[0].(*request.Request) 8058 ret1, _ := ret[1].(*ec2.DescribeFleetInstancesOutput) 8059 return ret0, ret1 8060 } 8061 8062 // DescribeFleetInstancesRequest indicates an expected call of DescribeFleetInstancesRequest 8063 func (mr *MockEC2APIMockRecorder) DescribeFleetInstancesRequest(arg0 interface{}) *gomock.Call { 8064 mr.mock.ctrl.T.Helper() 8065 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetInstancesRequest), arg0) 8066 } 8067 8068 // DescribeFleets mocks base method 8069 func (m *MockEC2API) DescribeFleets(arg0 *ec2.DescribeFleetsInput) (*ec2.DescribeFleetsOutput, error) { 8070 m.ctrl.T.Helper() 8071 ret := m.ctrl.Call(m, "DescribeFleets", arg0) 8072 ret0, _ := ret[0].(*ec2.DescribeFleetsOutput) 8073 ret1, _ := ret[1].(error) 8074 return ret0, ret1 8075 } 8076 8077 // DescribeFleets indicates an expected call of DescribeFleets 8078 func (mr *MockEC2APIMockRecorder) DescribeFleets(arg0 interface{}) *gomock.Call { 8079 mr.mock.ctrl.T.Helper() 8080 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleets", reflect.TypeOf((*MockEC2API)(nil).DescribeFleets), arg0) 8081 } 8082 8083 // DescribeFleetsWithContext mocks base method 8084 func (m *MockEC2API) DescribeFleetsWithContext(arg0 aws.Context, arg1 *ec2.DescribeFleetsInput, arg2 ...request.Option) (*ec2.DescribeFleetsOutput, error) { 8085 m.ctrl.T.Helper() 8086 varargs := []interface{}{arg0, arg1} 8087 for _, a := range arg2 { 8088 varargs = append(varargs, a) 8089 } 8090 ret := m.ctrl.Call(m, "DescribeFleetsWithContext", varargs...) 8091 ret0, _ := ret[0].(*ec2.DescribeFleetsOutput) 8092 ret1, _ := ret[1].(error) 8093 return ret0, ret1 8094 } 8095 8096 // DescribeFleetsWithContext indicates an expected call of DescribeFleetsWithContext 8097 func (mr *MockEC2APIMockRecorder) DescribeFleetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8098 mr.mock.ctrl.T.Helper() 8099 varargs := append([]interface{}{arg0, arg1}, arg2...) 8100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsWithContext), varargs...) 8101 } 8102 8103 // DescribeFleetsRequest mocks base method 8104 func (m *MockEC2API) DescribeFleetsRequest(arg0 *ec2.DescribeFleetsInput) (*request.Request, *ec2.DescribeFleetsOutput) { 8105 m.ctrl.T.Helper() 8106 ret := m.ctrl.Call(m, "DescribeFleetsRequest", arg0) 8107 ret0, _ := ret[0].(*request.Request) 8108 ret1, _ := ret[1].(*ec2.DescribeFleetsOutput) 8109 return ret0, ret1 8110 } 8111 8112 // DescribeFleetsRequest indicates an expected call of DescribeFleetsRequest 8113 func (mr *MockEC2APIMockRecorder) DescribeFleetsRequest(arg0 interface{}) *gomock.Call { 8114 mr.mock.ctrl.T.Helper() 8115 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsRequest), arg0) 8116 } 8117 8118 // DescribeFleetsPages mocks base method 8119 func (m *MockEC2API) DescribeFleetsPages(arg0 *ec2.DescribeFleetsInput, arg1 func(*ec2.DescribeFleetsOutput, bool) bool) error { 8120 m.ctrl.T.Helper() 8121 ret := m.ctrl.Call(m, "DescribeFleetsPages", arg0, arg1) 8122 ret0, _ := ret[0].(error) 8123 return ret0 8124 } 8125 8126 // DescribeFleetsPages indicates an expected call of DescribeFleetsPages 8127 func (mr *MockEC2APIMockRecorder) DescribeFleetsPages(arg0, arg1 interface{}) *gomock.Call { 8128 mr.mock.ctrl.T.Helper() 8129 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsPages), arg0, arg1) 8130 } 8131 8132 // DescribeFleetsPagesWithContext mocks base method 8133 func (m *MockEC2API) DescribeFleetsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeFleetsInput, arg2 func(*ec2.DescribeFleetsOutput, bool) bool, arg3 ...request.Option) error { 8134 m.ctrl.T.Helper() 8135 varargs := []interface{}{arg0, arg1, arg2} 8136 for _, a := range arg3 { 8137 varargs = append(varargs, a) 8138 } 8139 ret := m.ctrl.Call(m, "DescribeFleetsPagesWithContext", varargs...) 8140 ret0, _ := ret[0].(error) 8141 return ret0 8142 } 8143 8144 // DescribeFleetsPagesWithContext indicates an expected call of DescribeFleetsPagesWithContext 8145 func (mr *MockEC2APIMockRecorder) DescribeFleetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 8146 mr.mock.ctrl.T.Helper() 8147 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 8148 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFleetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFleetsPagesWithContext), varargs...) 8149 } 8150 8151 // DescribeFlowLogs mocks base method 8152 func (m *MockEC2API) DescribeFlowLogs(arg0 *ec2.DescribeFlowLogsInput) (*ec2.DescribeFlowLogsOutput, error) { 8153 m.ctrl.T.Helper() 8154 ret := m.ctrl.Call(m, "DescribeFlowLogs", arg0) 8155 ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput) 8156 ret1, _ := ret[1].(error) 8157 return ret0, ret1 8158 } 8159 8160 // DescribeFlowLogs indicates an expected call of DescribeFlowLogs 8161 func (mr *MockEC2APIMockRecorder) DescribeFlowLogs(arg0 interface{}) *gomock.Call { 8162 mr.mock.ctrl.T.Helper() 8163 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogs", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogs), arg0) 8164 } 8165 8166 // DescribeFlowLogsWithContext mocks base method 8167 func (m *MockEC2API) DescribeFlowLogsWithContext(arg0 aws.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 ...request.Option) (*ec2.DescribeFlowLogsOutput, error) { 8168 m.ctrl.T.Helper() 8169 varargs := []interface{}{arg0, arg1} 8170 for _, a := range arg2 { 8171 varargs = append(varargs, a) 8172 } 8173 ret := m.ctrl.Call(m, "DescribeFlowLogsWithContext", varargs...) 8174 ret0, _ := ret[0].(*ec2.DescribeFlowLogsOutput) 8175 ret1, _ := ret[1].(error) 8176 return ret0, ret1 8177 } 8178 8179 // DescribeFlowLogsWithContext indicates an expected call of DescribeFlowLogsWithContext 8180 func (mr *MockEC2APIMockRecorder) DescribeFlowLogsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8181 mr.mock.ctrl.T.Helper() 8182 varargs := append([]interface{}{arg0, arg1}, arg2...) 8183 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsWithContext), varargs...) 8184 } 8185 8186 // DescribeFlowLogsRequest mocks base method 8187 func (m *MockEC2API) DescribeFlowLogsRequest(arg0 *ec2.DescribeFlowLogsInput) (*request.Request, *ec2.DescribeFlowLogsOutput) { 8188 m.ctrl.T.Helper() 8189 ret := m.ctrl.Call(m, "DescribeFlowLogsRequest", arg0) 8190 ret0, _ := ret[0].(*request.Request) 8191 ret1, _ := ret[1].(*ec2.DescribeFlowLogsOutput) 8192 return ret0, ret1 8193 } 8194 8195 // DescribeFlowLogsRequest indicates an expected call of DescribeFlowLogsRequest 8196 func (mr *MockEC2APIMockRecorder) DescribeFlowLogsRequest(arg0 interface{}) *gomock.Call { 8197 mr.mock.ctrl.T.Helper() 8198 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsRequest), arg0) 8199 } 8200 8201 // DescribeFlowLogsPages mocks base method 8202 func (m *MockEC2API) DescribeFlowLogsPages(arg0 *ec2.DescribeFlowLogsInput, arg1 func(*ec2.DescribeFlowLogsOutput, bool) bool) error { 8203 m.ctrl.T.Helper() 8204 ret := m.ctrl.Call(m, "DescribeFlowLogsPages", arg0, arg1) 8205 ret0, _ := ret[0].(error) 8206 return ret0 8207 } 8208 8209 // DescribeFlowLogsPages indicates an expected call of DescribeFlowLogsPages 8210 func (mr *MockEC2APIMockRecorder) DescribeFlowLogsPages(arg0, arg1 interface{}) *gomock.Call { 8211 mr.mock.ctrl.T.Helper() 8212 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsPages), arg0, arg1) 8213 } 8214 8215 // DescribeFlowLogsPagesWithContext mocks base method 8216 func (m *MockEC2API) DescribeFlowLogsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeFlowLogsInput, arg2 func(*ec2.DescribeFlowLogsOutput, bool) bool, arg3 ...request.Option) error { 8217 m.ctrl.T.Helper() 8218 varargs := []interface{}{arg0, arg1, arg2} 8219 for _, a := range arg3 { 8220 varargs = append(varargs, a) 8221 } 8222 ret := m.ctrl.Call(m, "DescribeFlowLogsPagesWithContext", varargs...) 8223 ret0, _ := ret[0].(error) 8224 return ret0 8225 } 8226 8227 // DescribeFlowLogsPagesWithContext indicates an expected call of DescribeFlowLogsPagesWithContext 8228 func (mr *MockEC2APIMockRecorder) DescribeFlowLogsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 8229 mr.mock.ctrl.T.Helper() 8230 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 8231 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFlowLogsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFlowLogsPagesWithContext), varargs...) 8232 } 8233 8234 // DescribeFpgaImageAttribute mocks base method 8235 func (m *MockEC2API) DescribeFpgaImageAttribute(arg0 *ec2.DescribeFpgaImageAttributeInput) (*ec2.DescribeFpgaImageAttributeOutput, error) { 8236 m.ctrl.T.Helper() 8237 ret := m.ctrl.Call(m, "DescribeFpgaImageAttribute", arg0) 8238 ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput) 8239 ret1, _ := ret[1].(error) 8240 return ret0, ret1 8241 } 8242 8243 // DescribeFpgaImageAttribute indicates an expected call of DescribeFpgaImageAttribute 8244 func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttribute(arg0 interface{}) *gomock.Call { 8245 mr.mock.ctrl.T.Helper() 8246 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttribute), arg0) 8247 } 8248 8249 // DescribeFpgaImageAttributeWithContext mocks base method 8250 func (m *MockEC2API) DescribeFpgaImageAttributeWithContext(arg0 aws.Context, arg1 *ec2.DescribeFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeFpgaImageAttributeOutput, error) { 8251 m.ctrl.T.Helper() 8252 varargs := []interface{}{arg0, arg1} 8253 for _, a := range arg2 { 8254 varargs = append(varargs, a) 8255 } 8256 ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeWithContext", varargs...) 8257 ret0, _ := ret[0].(*ec2.DescribeFpgaImageAttributeOutput) 8258 ret1, _ := ret[1].(error) 8259 return ret0, ret1 8260 } 8261 8262 // DescribeFpgaImageAttributeWithContext indicates an expected call of DescribeFpgaImageAttributeWithContext 8263 func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8264 mr.mock.ctrl.T.Helper() 8265 varargs := append([]interface{}{arg0, arg1}, arg2...) 8266 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttributeWithContext), varargs...) 8267 } 8268 8269 // DescribeFpgaImageAttributeRequest mocks base method 8270 func (m *MockEC2API) DescribeFpgaImageAttributeRequest(arg0 *ec2.DescribeFpgaImageAttributeInput) (*request.Request, *ec2.DescribeFpgaImageAttributeOutput) { 8271 m.ctrl.T.Helper() 8272 ret := m.ctrl.Call(m, "DescribeFpgaImageAttributeRequest", arg0) 8273 ret0, _ := ret[0].(*request.Request) 8274 ret1, _ := ret[1].(*ec2.DescribeFpgaImageAttributeOutput) 8275 return ret0, ret1 8276 } 8277 8278 // DescribeFpgaImageAttributeRequest indicates an expected call of DescribeFpgaImageAttributeRequest 8279 func (mr *MockEC2APIMockRecorder) DescribeFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { 8280 mr.mock.ctrl.T.Helper() 8281 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImageAttributeRequest), arg0) 8282 } 8283 8284 // DescribeFpgaImages mocks base method 8285 func (m *MockEC2API) DescribeFpgaImages(arg0 *ec2.DescribeFpgaImagesInput) (*ec2.DescribeFpgaImagesOutput, error) { 8286 m.ctrl.T.Helper() 8287 ret := m.ctrl.Call(m, "DescribeFpgaImages", arg0) 8288 ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput) 8289 ret1, _ := ret[1].(error) 8290 return ret0, ret1 8291 } 8292 8293 // DescribeFpgaImages indicates an expected call of DescribeFpgaImages 8294 func (mr *MockEC2APIMockRecorder) DescribeFpgaImages(arg0 interface{}) *gomock.Call { 8295 mr.mock.ctrl.T.Helper() 8296 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImages), arg0) 8297 } 8298 8299 // DescribeFpgaImagesWithContext mocks base method 8300 func (m *MockEC2API) DescribeFpgaImagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 ...request.Option) (*ec2.DescribeFpgaImagesOutput, error) { 8301 m.ctrl.T.Helper() 8302 varargs := []interface{}{arg0, arg1} 8303 for _, a := range arg2 { 8304 varargs = append(varargs, a) 8305 } 8306 ret := m.ctrl.Call(m, "DescribeFpgaImagesWithContext", varargs...) 8307 ret0, _ := ret[0].(*ec2.DescribeFpgaImagesOutput) 8308 ret1, _ := ret[1].(error) 8309 return ret0, ret1 8310 } 8311 8312 // DescribeFpgaImagesWithContext indicates an expected call of DescribeFpgaImagesWithContext 8313 func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8314 mr.mock.ctrl.T.Helper() 8315 varargs := append([]interface{}{arg0, arg1}, arg2...) 8316 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesWithContext), varargs...) 8317 } 8318 8319 // DescribeFpgaImagesRequest mocks base method 8320 func (m *MockEC2API) DescribeFpgaImagesRequest(arg0 *ec2.DescribeFpgaImagesInput) (*request.Request, *ec2.DescribeFpgaImagesOutput) { 8321 m.ctrl.T.Helper() 8322 ret := m.ctrl.Call(m, "DescribeFpgaImagesRequest", arg0) 8323 ret0, _ := ret[0].(*request.Request) 8324 ret1, _ := ret[1].(*ec2.DescribeFpgaImagesOutput) 8325 return ret0, ret1 8326 } 8327 8328 // DescribeFpgaImagesRequest indicates an expected call of DescribeFpgaImagesRequest 8329 func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesRequest(arg0 interface{}) *gomock.Call { 8330 mr.mock.ctrl.T.Helper() 8331 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesRequest), arg0) 8332 } 8333 8334 // DescribeFpgaImagesPages mocks base method 8335 func (m *MockEC2API) DescribeFpgaImagesPages(arg0 *ec2.DescribeFpgaImagesInput, arg1 func(*ec2.DescribeFpgaImagesOutput, bool) bool) error { 8336 m.ctrl.T.Helper() 8337 ret := m.ctrl.Call(m, "DescribeFpgaImagesPages", arg0, arg1) 8338 ret0, _ := ret[0].(error) 8339 return ret0 8340 } 8341 8342 // DescribeFpgaImagesPages indicates an expected call of DescribeFpgaImagesPages 8343 func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesPages(arg0, arg1 interface{}) *gomock.Call { 8344 mr.mock.ctrl.T.Helper() 8345 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesPages), arg0, arg1) 8346 } 8347 8348 // DescribeFpgaImagesPagesWithContext mocks base method 8349 func (m *MockEC2API) DescribeFpgaImagesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeFpgaImagesInput, arg2 func(*ec2.DescribeFpgaImagesOutput, bool) bool, arg3 ...request.Option) error { 8350 m.ctrl.T.Helper() 8351 varargs := []interface{}{arg0, arg1, arg2} 8352 for _, a := range arg3 { 8353 varargs = append(varargs, a) 8354 } 8355 ret := m.ctrl.Call(m, "DescribeFpgaImagesPagesWithContext", varargs...) 8356 ret0, _ := ret[0].(error) 8357 return ret0 8358 } 8359 8360 // DescribeFpgaImagesPagesWithContext indicates an expected call of DescribeFpgaImagesPagesWithContext 8361 func (mr *MockEC2APIMockRecorder) DescribeFpgaImagesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 8362 mr.mock.ctrl.T.Helper() 8363 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 8364 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeFpgaImagesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeFpgaImagesPagesWithContext), varargs...) 8365 } 8366 8367 // DescribeHostReservationOfferings mocks base method 8368 func (m *MockEC2API) DescribeHostReservationOfferings(arg0 *ec2.DescribeHostReservationOfferingsInput) (*ec2.DescribeHostReservationOfferingsOutput, error) { 8369 m.ctrl.T.Helper() 8370 ret := m.ctrl.Call(m, "DescribeHostReservationOfferings", arg0) 8371 ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput) 8372 ret1, _ := ret[1].(error) 8373 return ret0, ret1 8374 } 8375 8376 // DescribeHostReservationOfferings indicates an expected call of DescribeHostReservationOfferings 8377 func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferings(arg0 interface{}) *gomock.Call { 8378 mr.mock.ctrl.T.Helper() 8379 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferings), arg0) 8380 } 8381 8382 // DescribeHostReservationOfferingsWithContext mocks base method 8383 func (m *MockEC2API) DescribeHostReservationOfferingsWithContext(arg0 aws.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationOfferingsOutput, error) { 8384 m.ctrl.T.Helper() 8385 varargs := []interface{}{arg0, arg1} 8386 for _, a := range arg2 { 8387 varargs = append(varargs, a) 8388 } 8389 ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsWithContext", varargs...) 8390 ret0, _ := ret[0].(*ec2.DescribeHostReservationOfferingsOutput) 8391 ret1, _ := ret[1].(error) 8392 return ret0, ret1 8393 } 8394 8395 // DescribeHostReservationOfferingsWithContext indicates an expected call of DescribeHostReservationOfferingsWithContext 8396 func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8397 mr.mock.ctrl.T.Helper() 8398 varargs := append([]interface{}{arg0, arg1}, arg2...) 8399 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsWithContext), varargs...) 8400 } 8401 8402 // DescribeHostReservationOfferingsRequest mocks base method 8403 func (m *MockEC2API) DescribeHostReservationOfferingsRequest(arg0 *ec2.DescribeHostReservationOfferingsInput) (*request.Request, *ec2.DescribeHostReservationOfferingsOutput) { 8404 m.ctrl.T.Helper() 8405 ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsRequest", arg0) 8406 ret0, _ := ret[0].(*request.Request) 8407 ret1, _ := ret[1].(*ec2.DescribeHostReservationOfferingsOutput) 8408 return ret0, ret1 8409 } 8410 8411 // DescribeHostReservationOfferingsRequest indicates an expected call of DescribeHostReservationOfferingsRequest 8412 func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsRequest(arg0 interface{}) *gomock.Call { 8413 mr.mock.ctrl.T.Helper() 8414 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsRequest), arg0) 8415 } 8416 8417 // DescribeHostReservationOfferingsPages mocks base method 8418 func (m *MockEC2API) DescribeHostReservationOfferingsPages(arg0 *ec2.DescribeHostReservationOfferingsInput, arg1 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool) error { 8419 m.ctrl.T.Helper() 8420 ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsPages", arg0, arg1) 8421 ret0, _ := ret[0].(error) 8422 return ret0 8423 } 8424 8425 // DescribeHostReservationOfferingsPages indicates an expected call of DescribeHostReservationOfferingsPages 8426 func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsPages(arg0, arg1 interface{}) *gomock.Call { 8427 mr.mock.ctrl.T.Helper() 8428 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsPages), arg0, arg1) 8429 } 8430 8431 // DescribeHostReservationOfferingsPagesWithContext mocks base method 8432 func (m *MockEC2API) DescribeHostReservationOfferingsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeHostReservationOfferingsInput, arg2 func(*ec2.DescribeHostReservationOfferingsOutput, bool) bool, arg3 ...request.Option) error { 8433 m.ctrl.T.Helper() 8434 varargs := []interface{}{arg0, arg1, arg2} 8435 for _, a := range arg3 { 8436 varargs = append(varargs, a) 8437 } 8438 ret := m.ctrl.Call(m, "DescribeHostReservationOfferingsPagesWithContext", varargs...) 8439 ret0, _ := ret[0].(error) 8440 return ret0 8441 } 8442 8443 // DescribeHostReservationOfferingsPagesWithContext indicates an expected call of DescribeHostReservationOfferingsPagesWithContext 8444 func (mr *MockEC2APIMockRecorder) DescribeHostReservationOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 8445 mr.mock.ctrl.T.Helper() 8446 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 8447 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationOfferingsPagesWithContext), varargs...) 8448 } 8449 8450 // DescribeHostReservations mocks base method 8451 func (m *MockEC2API) DescribeHostReservations(arg0 *ec2.DescribeHostReservationsInput) (*ec2.DescribeHostReservationsOutput, error) { 8452 m.ctrl.T.Helper() 8453 ret := m.ctrl.Call(m, "DescribeHostReservations", arg0) 8454 ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput) 8455 ret1, _ := ret[1].(error) 8456 return ret0, ret1 8457 } 8458 8459 // DescribeHostReservations indicates an expected call of DescribeHostReservations 8460 func (mr *MockEC2APIMockRecorder) DescribeHostReservations(arg0 interface{}) *gomock.Call { 8461 mr.mock.ctrl.T.Helper() 8462 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservations", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservations), arg0) 8463 } 8464 8465 // DescribeHostReservationsWithContext mocks base method 8466 func (m *MockEC2API) DescribeHostReservationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 ...request.Option) (*ec2.DescribeHostReservationsOutput, error) { 8467 m.ctrl.T.Helper() 8468 varargs := []interface{}{arg0, arg1} 8469 for _, a := range arg2 { 8470 varargs = append(varargs, a) 8471 } 8472 ret := m.ctrl.Call(m, "DescribeHostReservationsWithContext", varargs...) 8473 ret0, _ := ret[0].(*ec2.DescribeHostReservationsOutput) 8474 ret1, _ := ret[1].(error) 8475 return ret0, ret1 8476 } 8477 8478 // DescribeHostReservationsWithContext indicates an expected call of DescribeHostReservationsWithContext 8479 func (mr *MockEC2APIMockRecorder) DescribeHostReservationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8480 mr.mock.ctrl.T.Helper() 8481 varargs := append([]interface{}{arg0, arg1}, arg2...) 8482 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsWithContext), varargs...) 8483 } 8484 8485 // DescribeHostReservationsRequest mocks base method 8486 func (m *MockEC2API) DescribeHostReservationsRequest(arg0 *ec2.DescribeHostReservationsInput) (*request.Request, *ec2.DescribeHostReservationsOutput) { 8487 m.ctrl.T.Helper() 8488 ret := m.ctrl.Call(m, "DescribeHostReservationsRequest", arg0) 8489 ret0, _ := ret[0].(*request.Request) 8490 ret1, _ := ret[1].(*ec2.DescribeHostReservationsOutput) 8491 return ret0, ret1 8492 } 8493 8494 // DescribeHostReservationsRequest indicates an expected call of DescribeHostReservationsRequest 8495 func (mr *MockEC2APIMockRecorder) DescribeHostReservationsRequest(arg0 interface{}) *gomock.Call { 8496 mr.mock.ctrl.T.Helper() 8497 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsRequest), arg0) 8498 } 8499 8500 // DescribeHostReservationsPages mocks base method 8501 func (m *MockEC2API) DescribeHostReservationsPages(arg0 *ec2.DescribeHostReservationsInput, arg1 func(*ec2.DescribeHostReservationsOutput, bool) bool) error { 8502 m.ctrl.T.Helper() 8503 ret := m.ctrl.Call(m, "DescribeHostReservationsPages", arg0, arg1) 8504 ret0, _ := ret[0].(error) 8505 return ret0 8506 } 8507 8508 // DescribeHostReservationsPages indicates an expected call of DescribeHostReservationsPages 8509 func (mr *MockEC2APIMockRecorder) DescribeHostReservationsPages(arg0, arg1 interface{}) *gomock.Call { 8510 mr.mock.ctrl.T.Helper() 8511 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsPages), arg0, arg1) 8512 } 8513 8514 // DescribeHostReservationsPagesWithContext mocks base method 8515 func (m *MockEC2API) DescribeHostReservationsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeHostReservationsInput, arg2 func(*ec2.DescribeHostReservationsOutput, bool) bool, arg3 ...request.Option) error { 8516 m.ctrl.T.Helper() 8517 varargs := []interface{}{arg0, arg1, arg2} 8518 for _, a := range arg3 { 8519 varargs = append(varargs, a) 8520 } 8521 ret := m.ctrl.Call(m, "DescribeHostReservationsPagesWithContext", varargs...) 8522 ret0, _ := ret[0].(error) 8523 return ret0 8524 } 8525 8526 // DescribeHostReservationsPagesWithContext indicates an expected call of DescribeHostReservationsPagesWithContext 8527 func (mr *MockEC2APIMockRecorder) DescribeHostReservationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 8528 mr.mock.ctrl.T.Helper() 8529 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 8530 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostReservationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostReservationsPagesWithContext), varargs...) 8531 } 8532 8533 // DescribeHosts mocks base method 8534 func (m *MockEC2API) DescribeHosts(arg0 *ec2.DescribeHostsInput) (*ec2.DescribeHostsOutput, error) { 8535 m.ctrl.T.Helper() 8536 ret := m.ctrl.Call(m, "DescribeHosts", arg0) 8537 ret0, _ := ret[0].(*ec2.DescribeHostsOutput) 8538 ret1, _ := ret[1].(error) 8539 return ret0, ret1 8540 } 8541 8542 // DescribeHosts indicates an expected call of DescribeHosts 8543 func (mr *MockEC2APIMockRecorder) DescribeHosts(arg0 interface{}) *gomock.Call { 8544 mr.mock.ctrl.T.Helper() 8545 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHosts", reflect.TypeOf((*MockEC2API)(nil).DescribeHosts), arg0) 8546 } 8547 8548 // DescribeHostsWithContext mocks base method 8549 func (m *MockEC2API) DescribeHostsWithContext(arg0 aws.Context, arg1 *ec2.DescribeHostsInput, arg2 ...request.Option) (*ec2.DescribeHostsOutput, error) { 8550 m.ctrl.T.Helper() 8551 varargs := []interface{}{arg0, arg1} 8552 for _, a := range arg2 { 8553 varargs = append(varargs, a) 8554 } 8555 ret := m.ctrl.Call(m, "DescribeHostsWithContext", varargs...) 8556 ret0, _ := ret[0].(*ec2.DescribeHostsOutput) 8557 ret1, _ := ret[1].(error) 8558 return ret0, ret1 8559 } 8560 8561 // DescribeHostsWithContext indicates an expected call of DescribeHostsWithContext 8562 func (mr *MockEC2APIMockRecorder) DescribeHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8563 mr.mock.ctrl.T.Helper() 8564 varargs := append([]interface{}{arg0, arg1}, arg2...) 8565 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsWithContext), varargs...) 8566 } 8567 8568 // DescribeHostsRequest mocks base method 8569 func (m *MockEC2API) DescribeHostsRequest(arg0 *ec2.DescribeHostsInput) (*request.Request, *ec2.DescribeHostsOutput) { 8570 m.ctrl.T.Helper() 8571 ret := m.ctrl.Call(m, "DescribeHostsRequest", arg0) 8572 ret0, _ := ret[0].(*request.Request) 8573 ret1, _ := ret[1].(*ec2.DescribeHostsOutput) 8574 return ret0, ret1 8575 } 8576 8577 // DescribeHostsRequest indicates an expected call of DescribeHostsRequest 8578 func (mr *MockEC2APIMockRecorder) DescribeHostsRequest(arg0 interface{}) *gomock.Call { 8579 mr.mock.ctrl.T.Helper() 8580 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsRequest), arg0) 8581 } 8582 8583 // DescribeHostsPages mocks base method 8584 func (m *MockEC2API) DescribeHostsPages(arg0 *ec2.DescribeHostsInput, arg1 func(*ec2.DescribeHostsOutput, bool) bool) error { 8585 m.ctrl.T.Helper() 8586 ret := m.ctrl.Call(m, "DescribeHostsPages", arg0, arg1) 8587 ret0, _ := ret[0].(error) 8588 return ret0 8589 } 8590 8591 // DescribeHostsPages indicates an expected call of DescribeHostsPages 8592 func (mr *MockEC2APIMockRecorder) DescribeHostsPages(arg0, arg1 interface{}) *gomock.Call { 8593 mr.mock.ctrl.T.Helper() 8594 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsPages), arg0, arg1) 8595 } 8596 8597 // DescribeHostsPagesWithContext mocks base method 8598 func (m *MockEC2API) DescribeHostsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeHostsInput, arg2 func(*ec2.DescribeHostsOutput, bool) bool, arg3 ...request.Option) error { 8599 m.ctrl.T.Helper() 8600 varargs := []interface{}{arg0, arg1, arg2} 8601 for _, a := range arg3 { 8602 varargs = append(varargs, a) 8603 } 8604 ret := m.ctrl.Call(m, "DescribeHostsPagesWithContext", varargs...) 8605 ret0, _ := ret[0].(error) 8606 return ret0 8607 } 8608 8609 // DescribeHostsPagesWithContext indicates an expected call of DescribeHostsPagesWithContext 8610 func (mr *MockEC2APIMockRecorder) DescribeHostsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 8611 mr.mock.ctrl.T.Helper() 8612 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 8613 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeHostsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeHostsPagesWithContext), varargs...) 8614 } 8615 8616 // DescribeIamInstanceProfileAssociations mocks base method 8617 func (m *MockEC2API) DescribeIamInstanceProfileAssociations(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) { 8618 m.ctrl.T.Helper() 8619 ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociations", arg0) 8620 ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput) 8621 ret1, _ := ret[1].(error) 8622 return ret0, ret1 8623 } 8624 8625 // DescribeIamInstanceProfileAssociations indicates an expected call of DescribeIamInstanceProfileAssociations 8626 func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociations(arg0 interface{}) *gomock.Call { 8627 mr.mock.ctrl.T.Helper() 8628 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociations", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociations), arg0) 8629 } 8630 8631 // DescribeIamInstanceProfileAssociationsWithContext mocks base method 8632 func (m *MockEC2API) DescribeIamInstanceProfileAssociationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 ...request.Option) (*ec2.DescribeIamInstanceProfileAssociationsOutput, error) { 8633 m.ctrl.T.Helper() 8634 varargs := []interface{}{arg0, arg1} 8635 for _, a := range arg2 { 8636 varargs = append(varargs, a) 8637 } 8638 ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsWithContext", varargs...) 8639 ret0, _ := ret[0].(*ec2.DescribeIamInstanceProfileAssociationsOutput) 8640 ret1, _ := ret[1].(error) 8641 return ret0, ret1 8642 } 8643 8644 // DescribeIamInstanceProfileAssociationsWithContext indicates an expected call of DescribeIamInstanceProfileAssociationsWithContext 8645 func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8646 mr.mock.ctrl.T.Helper() 8647 varargs := append([]interface{}{arg0, arg1}, arg2...) 8648 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsWithContext), varargs...) 8649 } 8650 8651 // DescribeIamInstanceProfileAssociationsRequest mocks base method 8652 func (m *MockEC2API) DescribeIamInstanceProfileAssociationsRequest(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput) (*request.Request, *ec2.DescribeIamInstanceProfileAssociationsOutput) { 8653 m.ctrl.T.Helper() 8654 ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsRequest", arg0) 8655 ret0, _ := ret[0].(*request.Request) 8656 ret1, _ := ret[1].(*ec2.DescribeIamInstanceProfileAssociationsOutput) 8657 return ret0, ret1 8658 } 8659 8660 // DescribeIamInstanceProfileAssociationsRequest indicates an expected call of DescribeIamInstanceProfileAssociationsRequest 8661 func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsRequest(arg0 interface{}) *gomock.Call { 8662 mr.mock.ctrl.T.Helper() 8663 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsRequest), arg0) 8664 } 8665 8666 // DescribeIamInstanceProfileAssociationsPages mocks base method 8667 func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPages(arg0 *ec2.DescribeIamInstanceProfileAssociationsInput, arg1 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool) error { 8668 m.ctrl.T.Helper() 8669 ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsPages", arg0, arg1) 8670 ret0, _ := ret[0].(error) 8671 return ret0 8672 } 8673 8674 // DescribeIamInstanceProfileAssociationsPages indicates an expected call of DescribeIamInstanceProfileAssociationsPages 8675 func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsPages(arg0, arg1 interface{}) *gomock.Call { 8676 mr.mock.ctrl.T.Helper() 8677 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPages), arg0, arg1) 8678 } 8679 8680 // DescribeIamInstanceProfileAssociationsPagesWithContext mocks base method 8681 func (m *MockEC2API) DescribeIamInstanceProfileAssociationsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeIamInstanceProfileAssociationsInput, arg2 func(*ec2.DescribeIamInstanceProfileAssociationsOutput, bool) bool, arg3 ...request.Option) error { 8682 m.ctrl.T.Helper() 8683 varargs := []interface{}{arg0, arg1, arg2} 8684 for _, a := range arg3 { 8685 varargs = append(varargs, a) 8686 } 8687 ret := m.ctrl.Call(m, "DescribeIamInstanceProfileAssociationsPagesWithContext", varargs...) 8688 ret0, _ := ret[0].(error) 8689 return ret0 8690 } 8691 8692 // DescribeIamInstanceProfileAssociationsPagesWithContext indicates an expected call of DescribeIamInstanceProfileAssociationsPagesWithContext 8693 func (mr *MockEC2APIMockRecorder) DescribeIamInstanceProfileAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 8694 mr.mock.ctrl.T.Helper() 8695 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 8696 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIamInstanceProfileAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIamInstanceProfileAssociationsPagesWithContext), varargs...) 8697 } 8698 8699 // DescribeIdFormat mocks base method 8700 func (m *MockEC2API) DescribeIdFormat(arg0 *ec2.DescribeIdFormatInput) (*ec2.DescribeIdFormatOutput, error) { 8701 m.ctrl.T.Helper() 8702 ret := m.ctrl.Call(m, "DescribeIdFormat", arg0) 8703 ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput) 8704 ret1, _ := ret[1].(error) 8705 return ret0, ret1 8706 } 8707 8708 // DescribeIdFormat indicates an expected call of DescribeIdFormat 8709 func (mr *MockEC2APIMockRecorder) DescribeIdFormat(arg0 interface{}) *gomock.Call { 8710 mr.mock.ctrl.T.Helper() 8711 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormat), arg0) 8712 } 8713 8714 // DescribeIdFormatWithContext mocks base method 8715 func (m *MockEC2API) DescribeIdFormatWithContext(arg0 aws.Context, arg1 *ec2.DescribeIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdFormatOutput, error) { 8716 m.ctrl.T.Helper() 8717 varargs := []interface{}{arg0, arg1} 8718 for _, a := range arg2 { 8719 varargs = append(varargs, a) 8720 } 8721 ret := m.ctrl.Call(m, "DescribeIdFormatWithContext", varargs...) 8722 ret0, _ := ret[0].(*ec2.DescribeIdFormatOutput) 8723 ret1, _ := ret[1].(error) 8724 return ret0, ret1 8725 } 8726 8727 // DescribeIdFormatWithContext indicates an expected call of DescribeIdFormatWithContext 8728 func (mr *MockEC2APIMockRecorder) DescribeIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8729 mr.mock.ctrl.T.Helper() 8730 varargs := append([]interface{}{arg0, arg1}, arg2...) 8731 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormatWithContext), varargs...) 8732 } 8733 8734 // DescribeIdFormatRequest mocks base method 8735 func (m *MockEC2API) DescribeIdFormatRequest(arg0 *ec2.DescribeIdFormatInput) (*request.Request, *ec2.DescribeIdFormatOutput) { 8736 m.ctrl.T.Helper() 8737 ret := m.ctrl.Call(m, "DescribeIdFormatRequest", arg0) 8738 ret0, _ := ret[0].(*request.Request) 8739 ret1, _ := ret[1].(*ec2.DescribeIdFormatOutput) 8740 return ret0, ret1 8741 } 8742 8743 // DescribeIdFormatRequest indicates an expected call of DescribeIdFormatRequest 8744 func (mr *MockEC2APIMockRecorder) DescribeIdFormatRequest(arg0 interface{}) *gomock.Call { 8745 mr.mock.ctrl.T.Helper() 8746 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdFormatRequest), arg0) 8747 } 8748 8749 // DescribeIdentityIdFormat mocks base method 8750 func (m *MockEC2API) DescribeIdentityIdFormat(arg0 *ec2.DescribeIdentityIdFormatInput) (*ec2.DescribeIdentityIdFormatOutput, error) { 8751 m.ctrl.T.Helper() 8752 ret := m.ctrl.Call(m, "DescribeIdentityIdFormat", arg0) 8753 ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput) 8754 ret1, _ := ret[1].(error) 8755 return ret0, ret1 8756 } 8757 8758 // DescribeIdentityIdFormat indicates an expected call of DescribeIdentityIdFormat 8759 func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormat(arg0 interface{}) *gomock.Call { 8760 mr.mock.ctrl.T.Helper() 8761 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormat), arg0) 8762 } 8763 8764 // DescribeIdentityIdFormatWithContext mocks base method 8765 func (m *MockEC2API) DescribeIdentityIdFormatWithContext(arg0 aws.Context, arg1 *ec2.DescribeIdentityIdFormatInput, arg2 ...request.Option) (*ec2.DescribeIdentityIdFormatOutput, error) { 8766 m.ctrl.T.Helper() 8767 varargs := []interface{}{arg0, arg1} 8768 for _, a := range arg2 { 8769 varargs = append(varargs, a) 8770 } 8771 ret := m.ctrl.Call(m, "DescribeIdentityIdFormatWithContext", varargs...) 8772 ret0, _ := ret[0].(*ec2.DescribeIdentityIdFormatOutput) 8773 ret1, _ := ret[1].(error) 8774 return ret0, ret1 8775 } 8776 8777 // DescribeIdentityIdFormatWithContext indicates an expected call of DescribeIdentityIdFormatWithContext 8778 func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8779 mr.mock.ctrl.T.Helper() 8780 varargs := append([]interface{}{arg0, arg1}, arg2...) 8781 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormatWithContext), varargs...) 8782 } 8783 8784 // DescribeIdentityIdFormatRequest mocks base method 8785 func (m *MockEC2API) DescribeIdentityIdFormatRequest(arg0 *ec2.DescribeIdentityIdFormatInput) (*request.Request, *ec2.DescribeIdentityIdFormatOutput) { 8786 m.ctrl.T.Helper() 8787 ret := m.ctrl.Call(m, "DescribeIdentityIdFormatRequest", arg0) 8788 ret0, _ := ret[0].(*request.Request) 8789 ret1, _ := ret[1].(*ec2.DescribeIdentityIdFormatOutput) 8790 return ret0, ret1 8791 } 8792 8793 // DescribeIdentityIdFormatRequest indicates an expected call of DescribeIdentityIdFormatRequest 8794 func (mr *MockEC2APIMockRecorder) DescribeIdentityIdFormatRequest(arg0 interface{}) *gomock.Call { 8795 mr.mock.ctrl.T.Helper() 8796 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeIdentityIdFormatRequest), arg0) 8797 } 8798 8799 // DescribeImageAttribute mocks base method 8800 func (m *MockEC2API) DescribeImageAttribute(arg0 *ec2.DescribeImageAttributeInput) (*ec2.DescribeImageAttributeOutput, error) { 8801 m.ctrl.T.Helper() 8802 ret := m.ctrl.Call(m, "DescribeImageAttribute", arg0) 8803 ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput) 8804 ret1, _ := ret[1].(error) 8805 return ret0, ret1 8806 } 8807 8808 // DescribeImageAttribute indicates an expected call of DescribeImageAttribute 8809 func (mr *MockEC2APIMockRecorder) DescribeImageAttribute(arg0 interface{}) *gomock.Call { 8810 mr.mock.ctrl.T.Helper() 8811 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttribute), arg0) 8812 } 8813 8814 // DescribeImageAttributeWithContext mocks base method 8815 func (m *MockEC2API) DescribeImageAttributeWithContext(arg0 aws.Context, arg1 *ec2.DescribeImageAttributeInput, arg2 ...request.Option) (*ec2.DescribeImageAttributeOutput, error) { 8816 m.ctrl.T.Helper() 8817 varargs := []interface{}{arg0, arg1} 8818 for _, a := range arg2 { 8819 varargs = append(varargs, a) 8820 } 8821 ret := m.ctrl.Call(m, "DescribeImageAttributeWithContext", varargs...) 8822 ret0, _ := ret[0].(*ec2.DescribeImageAttributeOutput) 8823 ret1, _ := ret[1].(error) 8824 return ret0, ret1 8825 } 8826 8827 // DescribeImageAttributeWithContext indicates an expected call of DescribeImageAttributeWithContext 8828 func (mr *MockEC2APIMockRecorder) DescribeImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8829 mr.mock.ctrl.T.Helper() 8830 varargs := append([]interface{}{arg0, arg1}, arg2...) 8831 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttributeWithContext), varargs...) 8832 } 8833 8834 // DescribeImageAttributeRequest mocks base method 8835 func (m *MockEC2API) DescribeImageAttributeRequest(arg0 *ec2.DescribeImageAttributeInput) (*request.Request, *ec2.DescribeImageAttributeOutput) { 8836 m.ctrl.T.Helper() 8837 ret := m.ctrl.Call(m, "DescribeImageAttributeRequest", arg0) 8838 ret0, _ := ret[0].(*request.Request) 8839 ret1, _ := ret[1].(*ec2.DescribeImageAttributeOutput) 8840 return ret0, ret1 8841 } 8842 8843 // DescribeImageAttributeRequest indicates an expected call of DescribeImageAttributeRequest 8844 func (mr *MockEC2APIMockRecorder) DescribeImageAttributeRequest(arg0 interface{}) *gomock.Call { 8845 mr.mock.ctrl.T.Helper() 8846 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImageAttributeRequest), arg0) 8847 } 8848 8849 // DescribeImages mocks base method 8850 func (m *MockEC2API) DescribeImages(arg0 *ec2.DescribeImagesInput) (*ec2.DescribeImagesOutput, error) { 8851 m.ctrl.T.Helper() 8852 ret := m.ctrl.Call(m, "DescribeImages", arg0) 8853 ret0, _ := ret[0].(*ec2.DescribeImagesOutput) 8854 ret1, _ := ret[1].(error) 8855 return ret0, ret1 8856 } 8857 8858 // DescribeImages indicates an expected call of DescribeImages 8859 func (mr *MockEC2APIMockRecorder) DescribeImages(arg0 interface{}) *gomock.Call { 8860 mr.mock.ctrl.T.Helper() 8861 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImages", reflect.TypeOf((*MockEC2API)(nil).DescribeImages), arg0) 8862 } 8863 8864 // DescribeImagesWithContext mocks base method 8865 func (m *MockEC2API) DescribeImagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.Option) (*ec2.DescribeImagesOutput, error) { 8866 m.ctrl.T.Helper() 8867 varargs := []interface{}{arg0, arg1} 8868 for _, a := range arg2 { 8869 varargs = append(varargs, a) 8870 } 8871 ret := m.ctrl.Call(m, "DescribeImagesWithContext", varargs...) 8872 ret0, _ := ret[0].(*ec2.DescribeImagesOutput) 8873 ret1, _ := ret[1].(error) 8874 return ret0, ret1 8875 } 8876 8877 // DescribeImagesWithContext indicates an expected call of DescribeImagesWithContext 8878 func (mr *MockEC2APIMockRecorder) DescribeImagesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8879 mr.mock.ctrl.T.Helper() 8880 varargs := append([]interface{}{arg0, arg1}, arg2...) 8881 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesWithContext), varargs...) 8882 } 8883 8884 // DescribeImagesRequest mocks base method 8885 func (m *MockEC2API) DescribeImagesRequest(arg0 *ec2.DescribeImagesInput) (*request.Request, *ec2.DescribeImagesOutput) { 8886 m.ctrl.T.Helper() 8887 ret := m.ctrl.Call(m, "DescribeImagesRequest", arg0) 8888 ret0, _ := ret[0].(*request.Request) 8889 ret1, _ := ret[1].(*ec2.DescribeImagesOutput) 8890 return ret0, ret1 8891 } 8892 8893 // DescribeImagesRequest indicates an expected call of DescribeImagesRequest 8894 func (mr *MockEC2APIMockRecorder) DescribeImagesRequest(arg0 interface{}) *gomock.Call { 8895 mr.mock.ctrl.T.Helper() 8896 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImagesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImagesRequest), arg0) 8897 } 8898 8899 // DescribeImportImageTasks mocks base method 8900 func (m *MockEC2API) DescribeImportImageTasks(arg0 *ec2.DescribeImportImageTasksInput) (*ec2.DescribeImportImageTasksOutput, error) { 8901 m.ctrl.T.Helper() 8902 ret := m.ctrl.Call(m, "DescribeImportImageTasks", arg0) 8903 ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput) 8904 ret1, _ := ret[1].(error) 8905 return ret0, ret1 8906 } 8907 8908 // DescribeImportImageTasks indicates an expected call of DescribeImportImageTasks 8909 func (mr *MockEC2APIMockRecorder) DescribeImportImageTasks(arg0 interface{}) *gomock.Call { 8910 mr.mock.ctrl.T.Helper() 8911 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasks), arg0) 8912 } 8913 8914 // DescribeImportImageTasksWithContext mocks base method 8915 func (m *MockEC2API) DescribeImportImageTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 ...request.Option) (*ec2.DescribeImportImageTasksOutput, error) { 8916 m.ctrl.T.Helper() 8917 varargs := []interface{}{arg0, arg1} 8918 for _, a := range arg2 { 8919 varargs = append(varargs, a) 8920 } 8921 ret := m.ctrl.Call(m, "DescribeImportImageTasksWithContext", varargs...) 8922 ret0, _ := ret[0].(*ec2.DescribeImportImageTasksOutput) 8923 ret1, _ := ret[1].(error) 8924 return ret0, ret1 8925 } 8926 8927 // DescribeImportImageTasksWithContext indicates an expected call of DescribeImportImageTasksWithContext 8928 func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 8929 mr.mock.ctrl.T.Helper() 8930 varargs := append([]interface{}{arg0, arg1}, arg2...) 8931 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksWithContext), varargs...) 8932 } 8933 8934 // DescribeImportImageTasksRequest mocks base method 8935 func (m *MockEC2API) DescribeImportImageTasksRequest(arg0 *ec2.DescribeImportImageTasksInput) (*request.Request, *ec2.DescribeImportImageTasksOutput) { 8936 m.ctrl.T.Helper() 8937 ret := m.ctrl.Call(m, "DescribeImportImageTasksRequest", arg0) 8938 ret0, _ := ret[0].(*request.Request) 8939 ret1, _ := ret[1].(*ec2.DescribeImportImageTasksOutput) 8940 return ret0, ret1 8941 } 8942 8943 // DescribeImportImageTasksRequest indicates an expected call of DescribeImportImageTasksRequest 8944 func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksRequest(arg0 interface{}) *gomock.Call { 8945 mr.mock.ctrl.T.Helper() 8946 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksRequest), arg0) 8947 } 8948 8949 // DescribeImportImageTasksPages mocks base method 8950 func (m *MockEC2API) DescribeImportImageTasksPages(arg0 *ec2.DescribeImportImageTasksInput, arg1 func(*ec2.DescribeImportImageTasksOutput, bool) bool) error { 8951 m.ctrl.T.Helper() 8952 ret := m.ctrl.Call(m, "DescribeImportImageTasksPages", arg0, arg1) 8953 ret0, _ := ret[0].(error) 8954 return ret0 8955 } 8956 8957 // DescribeImportImageTasksPages indicates an expected call of DescribeImportImageTasksPages 8958 func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksPages(arg0, arg1 interface{}) *gomock.Call { 8959 mr.mock.ctrl.T.Helper() 8960 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPages), arg0, arg1) 8961 } 8962 8963 // DescribeImportImageTasksPagesWithContext mocks base method 8964 func (m *MockEC2API) DescribeImportImageTasksPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeImportImageTasksInput, arg2 func(*ec2.DescribeImportImageTasksOutput, bool) bool, arg3 ...request.Option) error { 8965 m.ctrl.T.Helper() 8966 varargs := []interface{}{arg0, arg1, arg2} 8967 for _, a := range arg3 { 8968 varargs = append(varargs, a) 8969 } 8970 ret := m.ctrl.Call(m, "DescribeImportImageTasksPagesWithContext", varargs...) 8971 ret0, _ := ret[0].(error) 8972 return ret0 8973 } 8974 8975 // DescribeImportImageTasksPagesWithContext indicates an expected call of DescribeImportImageTasksPagesWithContext 8976 func (mr *MockEC2APIMockRecorder) DescribeImportImageTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 8977 mr.mock.ctrl.T.Helper() 8978 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 8979 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportImageTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportImageTasksPagesWithContext), varargs...) 8980 } 8981 8982 // DescribeImportSnapshotTasks mocks base method 8983 func (m *MockEC2API) DescribeImportSnapshotTasks(arg0 *ec2.DescribeImportSnapshotTasksInput) (*ec2.DescribeImportSnapshotTasksOutput, error) { 8984 m.ctrl.T.Helper() 8985 ret := m.ctrl.Call(m, "DescribeImportSnapshotTasks", arg0) 8986 ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput) 8987 ret1, _ := ret[1].(error) 8988 return ret0, ret1 8989 } 8990 8991 // DescribeImportSnapshotTasks indicates an expected call of DescribeImportSnapshotTasks 8992 func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasks(arg0 interface{}) *gomock.Call { 8993 mr.mock.ctrl.T.Helper() 8994 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasks", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasks), arg0) 8995 } 8996 8997 // DescribeImportSnapshotTasksWithContext mocks base method 8998 func (m *MockEC2API) DescribeImportSnapshotTasksWithContext(arg0 aws.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 ...request.Option) (*ec2.DescribeImportSnapshotTasksOutput, error) { 8999 m.ctrl.T.Helper() 9000 varargs := []interface{}{arg0, arg1} 9001 for _, a := range arg2 { 9002 varargs = append(varargs, a) 9003 } 9004 ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksWithContext", varargs...) 9005 ret0, _ := ret[0].(*ec2.DescribeImportSnapshotTasksOutput) 9006 ret1, _ := ret[1].(error) 9007 return ret0, ret1 9008 } 9009 9010 // DescribeImportSnapshotTasksWithContext indicates an expected call of DescribeImportSnapshotTasksWithContext 9011 func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9012 mr.mock.ctrl.T.Helper() 9013 varargs := append([]interface{}{arg0, arg1}, arg2...) 9014 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksWithContext), varargs...) 9015 } 9016 9017 // DescribeImportSnapshotTasksRequest mocks base method 9018 func (m *MockEC2API) DescribeImportSnapshotTasksRequest(arg0 *ec2.DescribeImportSnapshotTasksInput) (*request.Request, *ec2.DescribeImportSnapshotTasksOutput) { 9019 m.ctrl.T.Helper() 9020 ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksRequest", arg0) 9021 ret0, _ := ret[0].(*request.Request) 9022 ret1, _ := ret[1].(*ec2.DescribeImportSnapshotTasksOutput) 9023 return ret0, ret1 9024 } 9025 9026 // DescribeImportSnapshotTasksRequest indicates an expected call of DescribeImportSnapshotTasksRequest 9027 func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksRequest(arg0 interface{}) *gomock.Call { 9028 mr.mock.ctrl.T.Helper() 9029 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksRequest), arg0) 9030 } 9031 9032 // DescribeImportSnapshotTasksPages mocks base method 9033 func (m *MockEC2API) DescribeImportSnapshotTasksPages(arg0 *ec2.DescribeImportSnapshotTasksInput, arg1 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool) error { 9034 m.ctrl.T.Helper() 9035 ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksPages", arg0, arg1) 9036 ret0, _ := ret[0].(error) 9037 return ret0 9038 } 9039 9040 // DescribeImportSnapshotTasksPages indicates an expected call of DescribeImportSnapshotTasksPages 9041 func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksPages(arg0, arg1 interface{}) *gomock.Call { 9042 mr.mock.ctrl.T.Helper() 9043 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksPages", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksPages), arg0, arg1) 9044 } 9045 9046 // DescribeImportSnapshotTasksPagesWithContext mocks base method 9047 func (m *MockEC2API) DescribeImportSnapshotTasksPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeImportSnapshotTasksInput, arg2 func(*ec2.DescribeImportSnapshotTasksOutput, bool) bool, arg3 ...request.Option) error { 9048 m.ctrl.T.Helper() 9049 varargs := []interface{}{arg0, arg1, arg2} 9050 for _, a := range arg3 { 9051 varargs = append(varargs, a) 9052 } 9053 ret := m.ctrl.Call(m, "DescribeImportSnapshotTasksPagesWithContext", varargs...) 9054 ret0, _ := ret[0].(error) 9055 return ret0 9056 } 9057 9058 // DescribeImportSnapshotTasksPagesWithContext indicates an expected call of DescribeImportSnapshotTasksPagesWithContext 9059 func (mr *MockEC2APIMockRecorder) DescribeImportSnapshotTasksPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9060 mr.mock.ctrl.T.Helper() 9061 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9062 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeImportSnapshotTasksPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeImportSnapshotTasksPagesWithContext), varargs...) 9063 } 9064 9065 // DescribeInstanceAttribute mocks base method 9066 func (m *MockEC2API) DescribeInstanceAttribute(arg0 *ec2.DescribeInstanceAttributeInput) (*ec2.DescribeInstanceAttributeOutput, error) { 9067 m.ctrl.T.Helper() 9068 ret := m.ctrl.Call(m, "DescribeInstanceAttribute", arg0) 9069 ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput) 9070 ret1, _ := ret[1].(error) 9071 return ret0, ret1 9072 } 9073 9074 // DescribeInstanceAttribute indicates an expected call of DescribeInstanceAttribute 9075 func (mr *MockEC2APIMockRecorder) DescribeInstanceAttribute(arg0 interface{}) *gomock.Call { 9076 mr.mock.ctrl.T.Helper() 9077 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttribute), arg0) 9078 } 9079 9080 // DescribeInstanceAttributeWithContext mocks base method 9081 func (m *MockEC2API) DescribeInstanceAttributeWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstanceAttributeInput, arg2 ...request.Option) (*ec2.DescribeInstanceAttributeOutput, error) { 9082 m.ctrl.T.Helper() 9083 varargs := []interface{}{arg0, arg1} 9084 for _, a := range arg2 { 9085 varargs = append(varargs, a) 9086 } 9087 ret := m.ctrl.Call(m, "DescribeInstanceAttributeWithContext", varargs...) 9088 ret0, _ := ret[0].(*ec2.DescribeInstanceAttributeOutput) 9089 ret1, _ := ret[1].(error) 9090 return ret0, ret1 9091 } 9092 9093 // DescribeInstanceAttributeWithContext indicates an expected call of DescribeInstanceAttributeWithContext 9094 func (mr *MockEC2APIMockRecorder) DescribeInstanceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9095 mr.mock.ctrl.T.Helper() 9096 varargs := append([]interface{}{arg0, arg1}, arg2...) 9097 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttributeWithContext), varargs...) 9098 } 9099 9100 // DescribeInstanceAttributeRequest mocks base method 9101 func (m *MockEC2API) DescribeInstanceAttributeRequest(arg0 *ec2.DescribeInstanceAttributeInput) (*request.Request, *ec2.DescribeInstanceAttributeOutput) { 9102 m.ctrl.T.Helper() 9103 ret := m.ctrl.Call(m, "DescribeInstanceAttributeRequest", arg0) 9104 ret0, _ := ret[0].(*request.Request) 9105 ret1, _ := ret[1].(*ec2.DescribeInstanceAttributeOutput) 9106 return ret0, ret1 9107 } 9108 9109 // DescribeInstanceAttributeRequest indicates an expected call of DescribeInstanceAttributeRequest 9110 func (mr *MockEC2APIMockRecorder) DescribeInstanceAttributeRequest(arg0 interface{}) *gomock.Call { 9111 mr.mock.ctrl.T.Helper() 9112 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceAttributeRequest), arg0) 9113 } 9114 9115 // DescribeInstanceCreditSpecifications mocks base method 9116 func (m *MockEC2API) DescribeInstanceCreditSpecifications(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) { 9117 m.ctrl.T.Helper() 9118 ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecifications", arg0) 9119 ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput) 9120 ret1, _ := ret[1].(error) 9121 return ret0, ret1 9122 } 9123 9124 // DescribeInstanceCreditSpecifications indicates an expected call of DescribeInstanceCreditSpecifications 9125 func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecifications(arg0 interface{}) *gomock.Call { 9126 mr.mock.ctrl.T.Helper() 9127 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecifications", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecifications), arg0) 9128 } 9129 9130 // DescribeInstanceCreditSpecificationsWithContext mocks base method 9131 func (m *MockEC2API) DescribeInstanceCreditSpecificationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 ...request.Option) (*ec2.DescribeInstanceCreditSpecificationsOutput, error) { 9132 m.ctrl.T.Helper() 9133 varargs := []interface{}{arg0, arg1} 9134 for _, a := range arg2 { 9135 varargs = append(varargs, a) 9136 } 9137 ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsWithContext", varargs...) 9138 ret0, _ := ret[0].(*ec2.DescribeInstanceCreditSpecificationsOutput) 9139 ret1, _ := ret[1].(error) 9140 return ret0, ret1 9141 } 9142 9143 // DescribeInstanceCreditSpecificationsWithContext indicates an expected call of DescribeInstanceCreditSpecificationsWithContext 9144 func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9145 mr.mock.ctrl.T.Helper() 9146 varargs := append([]interface{}{arg0, arg1}, arg2...) 9147 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsWithContext), varargs...) 9148 } 9149 9150 // DescribeInstanceCreditSpecificationsRequest mocks base method 9151 func (m *MockEC2API) DescribeInstanceCreditSpecificationsRequest(arg0 *ec2.DescribeInstanceCreditSpecificationsInput) (*request.Request, *ec2.DescribeInstanceCreditSpecificationsOutput) { 9152 m.ctrl.T.Helper() 9153 ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsRequest", arg0) 9154 ret0, _ := ret[0].(*request.Request) 9155 ret1, _ := ret[1].(*ec2.DescribeInstanceCreditSpecificationsOutput) 9156 return ret0, ret1 9157 } 9158 9159 // DescribeInstanceCreditSpecificationsRequest indicates an expected call of DescribeInstanceCreditSpecificationsRequest 9160 func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsRequest(arg0 interface{}) *gomock.Call { 9161 mr.mock.ctrl.T.Helper() 9162 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsRequest), arg0) 9163 } 9164 9165 // DescribeInstanceCreditSpecificationsPages mocks base method 9166 func (m *MockEC2API) DescribeInstanceCreditSpecificationsPages(arg0 *ec2.DescribeInstanceCreditSpecificationsInput, arg1 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool) error { 9167 m.ctrl.T.Helper() 9168 ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsPages", arg0, arg1) 9169 ret0, _ := ret[0].(error) 9170 return ret0 9171 } 9172 9173 // DescribeInstanceCreditSpecificationsPages indicates an expected call of DescribeInstanceCreditSpecificationsPages 9174 func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsPages(arg0, arg1 interface{}) *gomock.Call { 9175 mr.mock.ctrl.T.Helper() 9176 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPages), arg0, arg1) 9177 } 9178 9179 // DescribeInstanceCreditSpecificationsPagesWithContext mocks base method 9180 func (m *MockEC2API) DescribeInstanceCreditSpecificationsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstanceCreditSpecificationsInput, arg2 func(*ec2.DescribeInstanceCreditSpecificationsOutput, bool) bool, arg3 ...request.Option) error { 9181 m.ctrl.T.Helper() 9182 varargs := []interface{}{arg0, arg1, arg2} 9183 for _, a := range arg3 { 9184 varargs = append(varargs, a) 9185 } 9186 ret := m.ctrl.Call(m, "DescribeInstanceCreditSpecificationsPagesWithContext", varargs...) 9187 ret0, _ := ret[0].(error) 9188 return ret0 9189 } 9190 9191 // DescribeInstanceCreditSpecificationsPagesWithContext indicates an expected call of DescribeInstanceCreditSpecificationsPagesWithContext 9192 func (mr *MockEC2APIMockRecorder) DescribeInstanceCreditSpecificationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9193 mr.mock.ctrl.T.Helper() 9194 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9195 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceCreditSpecificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceCreditSpecificationsPagesWithContext), varargs...) 9196 } 9197 9198 // DescribeInstanceStatus mocks base method 9199 func (m *MockEC2API) DescribeInstanceStatus(arg0 *ec2.DescribeInstanceStatusInput) (*ec2.DescribeInstanceStatusOutput, error) { 9200 m.ctrl.T.Helper() 9201 ret := m.ctrl.Call(m, "DescribeInstanceStatus", arg0) 9202 ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput) 9203 ret1, _ := ret[1].(error) 9204 return ret0, ret1 9205 } 9206 9207 // DescribeInstanceStatus indicates an expected call of DescribeInstanceStatus 9208 func (mr *MockEC2APIMockRecorder) DescribeInstanceStatus(arg0 interface{}) *gomock.Call { 9209 mr.mock.ctrl.T.Helper() 9210 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatus), arg0) 9211 } 9212 9213 // DescribeInstanceStatusWithContext mocks base method 9214 func (m *MockEC2API) DescribeInstanceStatusWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.Option) (*ec2.DescribeInstanceStatusOutput, error) { 9215 m.ctrl.T.Helper() 9216 varargs := []interface{}{arg0, arg1} 9217 for _, a := range arg2 { 9218 varargs = append(varargs, a) 9219 } 9220 ret := m.ctrl.Call(m, "DescribeInstanceStatusWithContext", varargs...) 9221 ret0, _ := ret[0].(*ec2.DescribeInstanceStatusOutput) 9222 ret1, _ := ret[1].(error) 9223 return ret0, ret1 9224 } 9225 9226 // DescribeInstanceStatusWithContext indicates an expected call of DescribeInstanceStatusWithContext 9227 func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9228 mr.mock.ctrl.T.Helper() 9229 varargs := append([]interface{}{arg0, arg1}, arg2...) 9230 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusWithContext), varargs...) 9231 } 9232 9233 // DescribeInstanceStatusRequest mocks base method 9234 func (m *MockEC2API) DescribeInstanceStatusRequest(arg0 *ec2.DescribeInstanceStatusInput) (*request.Request, *ec2.DescribeInstanceStatusOutput) { 9235 m.ctrl.T.Helper() 9236 ret := m.ctrl.Call(m, "DescribeInstanceStatusRequest", arg0) 9237 ret0, _ := ret[0].(*request.Request) 9238 ret1, _ := ret[1].(*ec2.DescribeInstanceStatusOutput) 9239 return ret0, ret1 9240 } 9241 9242 // DescribeInstanceStatusRequest indicates an expected call of DescribeInstanceStatusRequest 9243 func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusRequest(arg0 interface{}) *gomock.Call { 9244 mr.mock.ctrl.T.Helper() 9245 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusRequest), arg0) 9246 } 9247 9248 // DescribeInstanceStatusPages mocks base method 9249 func (m *MockEC2API) DescribeInstanceStatusPages(arg0 *ec2.DescribeInstanceStatusInput, arg1 func(*ec2.DescribeInstanceStatusOutput, bool) bool) error { 9250 m.ctrl.T.Helper() 9251 ret := m.ctrl.Call(m, "DescribeInstanceStatusPages", arg0, arg1) 9252 ret0, _ := ret[0].(error) 9253 return ret0 9254 } 9255 9256 // DescribeInstanceStatusPages indicates an expected call of DescribeInstanceStatusPages 9257 func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusPages(arg0, arg1 interface{}) *gomock.Call { 9258 mr.mock.ctrl.T.Helper() 9259 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusPages), arg0, arg1) 9260 } 9261 9262 // DescribeInstanceStatusPagesWithContext mocks base method 9263 func (m *MockEC2API) DescribeInstanceStatusPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 func(*ec2.DescribeInstanceStatusOutput, bool) bool, arg3 ...request.Option) error { 9264 m.ctrl.T.Helper() 9265 varargs := []interface{}{arg0, arg1, arg2} 9266 for _, a := range arg3 { 9267 varargs = append(varargs, a) 9268 } 9269 ret := m.ctrl.Call(m, "DescribeInstanceStatusPagesWithContext", varargs...) 9270 ret0, _ := ret[0].(error) 9271 return ret0 9272 } 9273 9274 // DescribeInstanceStatusPagesWithContext indicates an expected call of DescribeInstanceStatusPagesWithContext 9275 func (mr *MockEC2APIMockRecorder) DescribeInstanceStatusPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9276 mr.mock.ctrl.T.Helper() 9277 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9278 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstanceStatusPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstanceStatusPagesWithContext), varargs...) 9279 } 9280 9281 // DescribeInstances mocks base method 9282 func (m *MockEC2API) DescribeInstances(arg0 *ec2.DescribeInstancesInput) (*ec2.DescribeInstancesOutput, error) { 9283 m.ctrl.T.Helper() 9284 ret := m.ctrl.Call(m, "DescribeInstances", arg0) 9285 ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) 9286 ret1, _ := ret[1].(error) 9287 return ret0, ret1 9288 } 9289 9290 // DescribeInstances indicates an expected call of DescribeInstances 9291 func (mr *MockEC2APIMockRecorder) DescribeInstances(arg0 interface{}) *gomock.Call { 9292 mr.mock.ctrl.T.Helper() 9293 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeInstances), arg0) 9294 } 9295 9296 // DescribeInstancesWithContext mocks base method 9297 func (m *MockEC2API) DescribeInstancesWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.Option) (*ec2.DescribeInstancesOutput, error) { 9298 m.ctrl.T.Helper() 9299 varargs := []interface{}{arg0, arg1} 9300 for _, a := range arg2 { 9301 varargs = append(varargs, a) 9302 } 9303 ret := m.ctrl.Call(m, "DescribeInstancesWithContext", varargs...) 9304 ret0, _ := ret[0].(*ec2.DescribeInstancesOutput) 9305 ret1, _ := ret[1].(error) 9306 return ret0, ret1 9307 } 9308 9309 // DescribeInstancesWithContext indicates an expected call of DescribeInstancesWithContext 9310 func (mr *MockEC2APIMockRecorder) DescribeInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9311 mr.mock.ctrl.T.Helper() 9312 varargs := append([]interface{}{arg0, arg1}, arg2...) 9313 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesWithContext), varargs...) 9314 } 9315 9316 // DescribeInstancesRequest mocks base method 9317 func (m *MockEC2API) DescribeInstancesRequest(arg0 *ec2.DescribeInstancesInput) (*request.Request, *ec2.DescribeInstancesOutput) { 9318 m.ctrl.T.Helper() 9319 ret := m.ctrl.Call(m, "DescribeInstancesRequest", arg0) 9320 ret0, _ := ret[0].(*request.Request) 9321 ret1, _ := ret[1].(*ec2.DescribeInstancesOutput) 9322 return ret0, ret1 9323 } 9324 9325 // DescribeInstancesRequest indicates an expected call of DescribeInstancesRequest 9326 func (mr *MockEC2APIMockRecorder) DescribeInstancesRequest(arg0 interface{}) *gomock.Call { 9327 mr.mock.ctrl.T.Helper() 9328 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesRequest), arg0) 9329 } 9330 9331 // DescribeInstancesPages mocks base method 9332 func (m *MockEC2API) DescribeInstancesPages(arg0 *ec2.DescribeInstancesInput, arg1 func(*ec2.DescribeInstancesOutput, bool) bool) error { 9333 m.ctrl.T.Helper() 9334 ret := m.ctrl.Call(m, "DescribeInstancesPages", arg0, arg1) 9335 ret0, _ := ret[0].(error) 9336 return ret0 9337 } 9338 9339 // DescribeInstancesPages indicates an expected call of DescribeInstancesPages 9340 func (mr *MockEC2APIMockRecorder) DescribeInstancesPages(arg0, arg1 interface{}) *gomock.Call { 9341 mr.mock.ctrl.T.Helper() 9342 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesPages), arg0, arg1) 9343 } 9344 9345 // DescribeInstancesPagesWithContext mocks base method 9346 func (m *MockEC2API) DescribeInstancesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstancesInput, arg2 func(*ec2.DescribeInstancesOutput, bool) bool, arg3 ...request.Option) error { 9347 m.ctrl.T.Helper() 9348 varargs := []interface{}{arg0, arg1, arg2} 9349 for _, a := range arg3 { 9350 varargs = append(varargs, a) 9351 } 9352 ret := m.ctrl.Call(m, "DescribeInstancesPagesWithContext", varargs...) 9353 ret0, _ := ret[0].(error) 9354 return ret0 9355 } 9356 9357 // DescribeInstancesPagesWithContext indicates an expected call of DescribeInstancesPagesWithContext 9358 func (mr *MockEC2APIMockRecorder) DescribeInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9359 mr.mock.ctrl.T.Helper() 9360 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9361 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInstancesPagesWithContext), varargs...) 9362 } 9363 9364 // DescribeInternetGateways mocks base method 9365 func (m *MockEC2API) DescribeInternetGateways(arg0 *ec2.DescribeInternetGatewaysInput) (*ec2.DescribeInternetGatewaysOutput, error) { 9366 m.ctrl.T.Helper() 9367 ret := m.ctrl.Call(m, "DescribeInternetGateways", arg0) 9368 ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput) 9369 ret1, _ := ret[1].(error) 9370 return ret0, ret1 9371 } 9372 9373 // DescribeInternetGateways indicates an expected call of DescribeInternetGateways 9374 func (mr *MockEC2APIMockRecorder) DescribeInternetGateways(arg0 interface{}) *gomock.Call { 9375 mr.mock.ctrl.T.Helper() 9376 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGateways), arg0) 9377 } 9378 9379 // DescribeInternetGatewaysWithContext mocks base method 9380 func (m *MockEC2API) DescribeInternetGatewaysWithContext(arg0 aws.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 ...request.Option) (*ec2.DescribeInternetGatewaysOutput, error) { 9381 m.ctrl.T.Helper() 9382 varargs := []interface{}{arg0, arg1} 9383 for _, a := range arg2 { 9384 varargs = append(varargs, a) 9385 } 9386 ret := m.ctrl.Call(m, "DescribeInternetGatewaysWithContext", varargs...) 9387 ret0, _ := ret[0].(*ec2.DescribeInternetGatewaysOutput) 9388 ret1, _ := ret[1].(error) 9389 return ret0, ret1 9390 } 9391 9392 // DescribeInternetGatewaysWithContext indicates an expected call of DescribeInternetGatewaysWithContext 9393 func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9394 mr.mock.ctrl.T.Helper() 9395 varargs := append([]interface{}{arg0, arg1}, arg2...) 9396 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysWithContext), varargs...) 9397 } 9398 9399 // DescribeInternetGatewaysRequest mocks base method 9400 func (m *MockEC2API) DescribeInternetGatewaysRequest(arg0 *ec2.DescribeInternetGatewaysInput) (*request.Request, *ec2.DescribeInternetGatewaysOutput) { 9401 m.ctrl.T.Helper() 9402 ret := m.ctrl.Call(m, "DescribeInternetGatewaysRequest", arg0) 9403 ret0, _ := ret[0].(*request.Request) 9404 ret1, _ := ret[1].(*ec2.DescribeInternetGatewaysOutput) 9405 return ret0, ret1 9406 } 9407 9408 // DescribeInternetGatewaysRequest indicates an expected call of DescribeInternetGatewaysRequest 9409 func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysRequest(arg0 interface{}) *gomock.Call { 9410 mr.mock.ctrl.T.Helper() 9411 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysRequest), arg0) 9412 } 9413 9414 // DescribeInternetGatewaysPages mocks base method 9415 func (m *MockEC2API) DescribeInternetGatewaysPages(arg0 *ec2.DescribeInternetGatewaysInput, arg1 func(*ec2.DescribeInternetGatewaysOutput, bool) bool) error { 9416 m.ctrl.T.Helper() 9417 ret := m.ctrl.Call(m, "DescribeInternetGatewaysPages", arg0, arg1) 9418 ret0, _ := ret[0].(error) 9419 return ret0 9420 } 9421 9422 // DescribeInternetGatewaysPages indicates an expected call of DescribeInternetGatewaysPages 9423 func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysPages(arg0, arg1 interface{}) *gomock.Call { 9424 mr.mock.ctrl.T.Helper() 9425 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysPages), arg0, arg1) 9426 } 9427 9428 // DescribeInternetGatewaysPagesWithContext mocks base method 9429 func (m *MockEC2API) DescribeInternetGatewaysPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeInternetGatewaysInput, arg2 func(*ec2.DescribeInternetGatewaysOutput, bool) bool, arg3 ...request.Option) error { 9430 m.ctrl.T.Helper() 9431 varargs := []interface{}{arg0, arg1, arg2} 9432 for _, a := range arg3 { 9433 varargs = append(varargs, a) 9434 } 9435 ret := m.ctrl.Call(m, "DescribeInternetGatewaysPagesWithContext", varargs...) 9436 ret0, _ := ret[0].(error) 9437 return ret0 9438 } 9439 9440 // DescribeInternetGatewaysPagesWithContext indicates an expected call of DescribeInternetGatewaysPagesWithContext 9441 func (mr *MockEC2APIMockRecorder) DescribeInternetGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9442 mr.mock.ctrl.T.Helper() 9443 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9444 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeInternetGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeInternetGatewaysPagesWithContext), varargs...) 9445 } 9446 9447 // DescribeKeyPairs mocks base method 9448 func (m *MockEC2API) DescribeKeyPairs(arg0 *ec2.DescribeKeyPairsInput) (*ec2.DescribeKeyPairsOutput, error) { 9449 m.ctrl.T.Helper() 9450 ret := m.ctrl.Call(m, "DescribeKeyPairs", arg0) 9451 ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput) 9452 ret1, _ := ret[1].(error) 9453 return ret0, ret1 9454 } 9455 9456 // DescribeKeyPairs indicates an expected call of DescribeKeyPairs 9457 func (mr *MockEC2APIMockRecorder) DescribeKeyPairs(arg0 interface{}) *gomock.Call { 9458 mr.mock.ctrl.T.Helper() 9459 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairs", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairs), arg0) 9460 } 9461 9462 // DescribeKeyPairsWithContext mocks base method 9463 func (m *MockEC2API) DescribeKeyPairsWithContext(arg0 aws.Context, arg1 *ec2.DescribeKeyPairsInput, arg2 ...request.Option) (*ec2.DescribeKeyPairsOutput, error) { 9464 m.ctrl.T.Helper() 9465 varargs := []interface{}{arg0, arg1} 9466 for _, a := range arg2 { 9467 varargs = append(varargs, a) 9468 } 9469 ret := m.ctrl.Call(m, "DescribeKeyPairsWithContext", varargs...) 9470 ret0, _ := ret[0].(*ec2.DescribeKeyPairsOutput) 9471 ret1, _ := ret[1].(error) 9472 return ret0, ret1 9473 } 9474 9475 // DescribeKeyPairsWithContext indicates an expected call of DescribeKeyPairsWithContext 9476 func (mr *MockEC2APIMockRecorder) DescribeKeyPairsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9477 mr.mock.ctrl.T.Helper() 9478 varargs := append([]interface{}{arg0, arg1}, arg2...) 9479 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairsWithContext), varargs...) 9480 } 9481 9482 // DescribeKeyPairsRequest mocks base method 9483 func (m *MockEC2API) DescribeKeyPairsRequest(arg0 *ec2.DescribeKeyPairsInput) (*request.Request, *ec2.DescribeKeyPairsOutput) { 9484 m.ctrl.T.Helper() 9485 ret := m.ctrl.Call(m, "DescribeKeyPairsRequest", arg0) 9486 ret0, _ := ret[0].(*request.Request) 9487 ret1, _ := ret[1].(*ec2.DescribeKeyPairsOutput) 9488 return ret0, ret1 9489 } 9490 9491 // DescribeKeyPairsRequest indicates an expected call of DescribeKeyPairsRequest 9492 func (mr *MockEC2APIMockRecorder) DescribeKeyPairsRequest(arg0 interface{}) *gomock.Call { 9493 mr.mock.ctrl.T.Helper() 9494 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeKeyPairsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeKeyPairsRequest), arg0) 9495 } 9496 9497 // DescribeLaunchTemplateVersions mocks base method 9498 func (m *MockEC2API) DescribeLaunchTemplateVersions(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*ec2.DescribeLaunchTemplateVersionsOutput, error) { 9499 m.ctrl.T.Helper() 9500 ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersions", arg0) 9501 ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput) 9502 ret1, _ := ret[1].(error) 9503 return ret0, ret1 9504 } 9505 9506 // DescribeLaunchTemplateVersions indicates an expected call of DescribeLaunchTemplateVersions 9507 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersions(arg0 interface{}) *gomock.Call { 9508 mr.mock.ctrl.T.Helper() 9509 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersions", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersions), arg0) 9510 } 9511 9512 // DescribeLaunchTemplateVersionsWithContext mocks base method 9513 func (m *MockEC2API) DescribeLaunchTemplateVersionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplateVersionsOutput, error) { 9514 m.ctrl.T.Helper() 9515 varargs := []interface{}{arg0, arg1} 9516 for _, a := range arg2 { 9517 varargs = append(varargs, a) 9518 } 9519 ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsWithContext", varargs...) 9520 ret0, _ := ret[0].(*ec2.DescribeLaunchTemplateVersionsOutput) 9521 ret1, _ := ret[1].(error) 9522 return ret0, ret1 9523 } 9524 9525 // DescribeLaunchTemplateVersionsWithContext indicates an expected call of DescribeLaunchTemplateVersionsWithContext 9526 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9527 mr.mock.ctrl.T.Helper() 9528 varargs := append([]interface{}{arg0, arg1}, arg2...) 9529 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsWithContext), varargs...) 9530 } 9531 9532 // DescribeLaunchTemplateVersionsRequest mocks base method 9533 func (m *MockEC2API) DescribeLaunchTemplateVersionsRequest(arg0 *ec2.DescribeLaunchTemplateVersionsInput) (*request.Request, *ec2.DescribeLaunchTemplateVersionsOutput) { 9534 m.ctrl.T.Helper() 9535 ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsRequest", arg0) 9536 ret0, _ := ret[0].(*request.Request) 9537 ret1, _ := ret[1].(*ec2.DescribeLaunchTemplateVersionsOutput) 9538 return ret0, ret1 9539 } 9540 9541 // DescribeLaunchTemplateVersionsRequest indicates an expected call of DescribeLaunchTemplateVersionsRequest 9542 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsRequest(arg0 interface{}) *gomock.Call { 9543 mr.mock.ctrl.T.Helper() 9544 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsRequest), arg0) 9545 } 9546 9547 // DescribeLaunchTemplateVersionsPages mocks base method 9548 func (m *MockEC2API) DescribeLaunchTemplateVersionsPages(arg0 *ec2.DescribeLaunchTemplateVersionsInput, arg1 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool) error { 9549 m.ctrl.T.Helper() 9550 ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsPages", arg0, arg1) 9551 ret0, _ := ret[0].(error) 9552 return ret0 9553 } 9554 9555 // DescribeLaunchTemplateVersionsPages indicates an expected call of DescribeLaunchTemplateVersionsPages 9556 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsPages(arg0, arg1 interface{}) *gomock.Call { 9557 mr.mock.ctrl.T.Helper() 9558 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPages), arg0, arg1) 9559 } 9560 9561 // DescribeLaunchTemplateVersionsPagesWithContext mocks base method 9562 func (m *MockEC2API) DescribeLaunchTemplateVersionsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeLaunchTemplateVersionsInput, arg2 func(*ec2.DescribeLaunchTemplateVersionsOutput, bool) bool, arg3 ...request.Option) error { 9563 m.ctrl.T.Helper() 9564 varargs := []interface{}{arg0, arg1, arg2} 9565 for _, a := range arg3 { 9566 varargs = append(varargs, a) 9567 } 9568 ret := m.ctrl.Call(m, "DescribeLaunchTemplateVersionsPagesWithContext", varargs...) 9569 ret0, _ := ret[0].(error) 9570 return ret0 9571 } 9572 9573 // DescribeLaunchTemplateVersionsPagesWithContext indicates an expected call of DescribeLaunchTemplateVersionsPagesWithContext 9574 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplateVersionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9575 mr.mock.ctrl.T.Helper() 9576 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9577 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplateVersionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplateVersionsPagesWithContext), varargs...) 9578 } 9579 9580 // DescribeLaunchTemplates mocks base method 9581 func (m *MockEC2API) DescribeLaunchTemplates(arg0 *ec2.DescribeLaunchTemplatesInput) (*ec2.DescribeLaunchTemplatesOutput, error) { 9582 m.ctrl.T.Helper() 9583 ret := m.ctrl.Call(m, "DescribeLaunchTemplates", arg0) 9584 ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput) 9585 ret1, _ := ret[1].(error) 9586 return ret0, ret1 9587 } 9588 9589 // DescribeLaunchTemplates indicates an expected call of DescribeLaunchTemplates 9590 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplates(arg0 interface{}) *gomock.Call { 9591 mr.mock.ctrl.T.Helper() 9592 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplates", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplates), arg0) 9593 } 9594 9595 // DescribeLaunchTemplatesWithContext mocks base method 9596 func (m *MockEC2API) DescribeLaunchTemplatesWithContext(arg0 aws.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 ...request.Option) (*ec2.DescribeLaunchTemplatesOutput, error) { 9597 m.ctrl.T.Helper() 9598 varargs := []interface{}{arg0, arg1} 9599 for _, a := range arg2 { 9600 varargs = append(varargs, a) 9601 } 9602 ret := m.ctrl.Call(m, "DescribeLaunchTemplatesWithContext", varargs...) 9603 ret0, _ := ret[0].(*ec2.DescribeLaunchTemplatesOutput) 9604 ret1, _ := ret[1].(error) 9605 return ret0, ret1 9606 } 9607 9608 // DescribeLaunchTemplatesWithContext indicates an expected call of DescribeLaunchTemplatesWithContext 9609 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9610 mr.mock.ctrl.T.Helper() 9611 varargs := append([]interface{}{arg0, arg1}, arg2...) 9612 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesWithContext), varargs...) 9613 } 9614 9615 // DescribeLaunchTemplatesRequest mocks base method 9616 func (m *MockEC2API) DescribeLaunchTemplatesRequest(arg0 *ec2.DescribeLaunchTemplatesInput) (*request.Request, *ec2.DescribeLaunchTemplatesOutput) { 9617 m.ctrl.T.Helper() 9618 ret := m.ctrl.Call(m, "DescribeLaunchTemplatesRequest", arg0) 9619 ret0, _ := ret[0].(*request.Request) 9620 ret1, _ := ret[1].(*ec2.DescribeLaunchTemplatesOutput) 9621 return ret0, ret1 9622 } 9623 9624 // DescribeLaunchTemplatesRequest indicates an expected call of DescribeLaunchTemplatesRequest 9625 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesRequest(arg0 interface{}) *gomock.Call { 9626 mr.mock.ctrl.T.Helper() 9627 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesRequest), arg0) 9628 } 9629 9630 // DescribeLaunchTemplatesPages mocks base method 9631 func (m *MockEC2API) DescribeLaunchTemplatesPages(arg0 *ec2.DescribeLaunchTemplatesInput, arg1 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool) error { 9632 m.ctrl.T.Helper() 9633 ret := m.ctrl.Call(m, "DescribeLaunchTemplatesPages", arg0, arg1) 9634 ret0, _ := ret[0].(error) 9635 return ret0 9636 } 9637 9638 // DescribeLaunchTemplatesPages indicates an expected call of DescribeLaunchTemplatesPages 9639 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesPages(arg0, arg1 interface{}) *gomock.Call { 9640 mr.mock.ctrl.T.Helper() 9641 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesPages), arg0, arg1) 9642 } 9643 9644 // DescribeLaunchTemplatesPagesWithContext mocks base method 9645 func (m *MockEC2API) DescribeLaunchTemplatesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeLaunchTemplatesInput, arg2 func(*ec2.DescribeLaunchTemplatesOutput, bool) bool, arg3 ...request.Option) error { 9646 m.ctrl.T.Helper() 9647 varargs := []interface{}{arg0, arg1, arg2} 9648 for _, a := range arg3 { 9649 varargs = append(varargs, a) 9650 } 9651 ret := m.ctrl.Call(m, "DescribeLaunchTemplatesPagesWithContext", varargs...) 9652 ret0, _ := ret[0].(error) 9653 return ret0 9654 } 9655 9656 // DescribeLaunchTemplatesPagesWithContext indicates an expected call of DescribeLaunchTemplatesPagesWithContext 9657 func (mr *MockEC2APIMockRecorder) DescribeLaunchTemplatesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9658 mr.mock.ctrl.T.Helper() 9659 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9660 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeLaunchTemplatesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeLaunchTemplatesPagesWithContext), varargs...) 9661 } 9662 9663 // DescribeMovingAddresses mocks base method 9664 func (m *MockEC2API) DescribeMovingAddresses(arg0 *ec2.DescribeMovingAddressesInput) (*ec2.DescribeMovingAddressesOutput, error) { 9665 m.ctrl.T.Helper() 9666 ret := m.ctrl.Call(m, "DescribeMovingAddresses", arg0) 9667 ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput) 9668 ret1, _ := ret[1].(error) 9669 return ret0, ret1 9670 } 9671 9672 // DescribeMovingAddresses indicates an expected call of DescribeMovingAddresses 9673 func (mr *MockEC2APIMockRecorder) DescribeMovingAddresses(arg0 interface{}) *gomock.Call { 9674 mr.mock.ctrl.T.Helper() 9675 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddresses", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddresses), arg0) 9676 } 9677 9678 // DescribeMovingAddressesWithContext mocks base method 9679 func (m *MockEC2API) DescribeMovingAddressesWithContext(arg0 aws.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 ...request.Option) (*ec2.DescribeMovingAddressesOutput, error) { 9680 m.ctrl.T.Helper() 9681 varargs := []interface{}{arg0, arg1} 9682 for _, a := range arg2 { 9683 varargs = append(varargs, a) 9684 } 9685 ret := m.ctrl.Call(m, "DescribeMovingAddressesWithContext", varargs...) 9686 ret0, _ := ret[0].(*ec2.DescribeMovingAddressesOutput) 9687 ret1, _ := ret[1].(error) 9688 return ret0, ret1 9689 } 9690 9691 // DescribeMovingAddressesWithContext indicates an expected call of DescribeMovingAddressesWithContext 9692 func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9693 mr.mock.ctrl.T.Helper() 9694 varargs := append([]interface{}{arg0, arg1}, arg2...) 9695 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesWithContext), varargs...) 9696 } 9697 9698 // DescribeMovingAddressesRequest mocks base method 9699 func (m *MockEC2API) DescribeMovingAddressesRequest(arg0 *ec2.DescribeMovingAddressesInput) (*request.Request, *ec2.DescribeMovingAddressesOutput) { 9700 m.ctrl.T.Helper() 9701 ret := m.ctrl.Call(m, "DescribeMovingAddressesRequest", arg0) 9702 ret0, _ := ret[0].(*request.Request) 9703 ret1, _ := ret[1].(*ec2.DescribeMovingAddressesOutput) 9704 return ret0, ret1 9705 } 9706 9707 // DescribeMovingAddressesRequest indicates an expected call of DescribeMovingAddressesRequest 9708 func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesRequest(arg0 interface{}) *gomock.Call { 9709 mr.mock.ctrl.T.Helper() 9710 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesRequest), arg0) 9711 } 9712 9713 // DescribeMovingAddressesPages mocks base method 9714 func (m *MockEC2API) DescribeMovingAddressesPages(arg0 *ec2.DescribeMovingAddressesInput, arg1 func(*ec2.DescribeMovingAddressesOutput, bool) bool) error { 9715 m.ctrl.T.Helper() 9716 ret := m.ctrl.Call(m, "DescribeMovingAddressesPages", arg0, arg1) 9717 ret0, _ := ret[0].(error) 9718 return ret0 9719 } 9720 9721 // DescribeMovingAddressesPages indicates an expected call of DescribeMovingAddressesPages 9722 func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesPages(arg0, arg1 interface{}) *gomock.Call { 9723 mr.mock.ctrl.T.Helper() 9724 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesPages), arg0, arg1) 9725 } 9726 9727 // DescribeMovingAddressesPagesWithContext mocks base method 9728 func (m *MockEC2API) DescribeMovingAddressesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeMovingAddressesInput, arg2 func(*ec2.DescribeMovingAddressesOutput, bool) bool, arg3 ...request.Option) error { 9729 m.ctrl.T.Helper() 9730 varargs := []interface{}{arg0, arg1, arg2} 9731 for _, a := range arg3 { 9732 varargs = append(varargs, a) 9733 } 9734 ret := m.ctrl.Call(m, "DescribeMovingAddressesPagesWithContext", varargs...) 9735 ret0, _ := ret[0].(error) 9736 return ret0 9737 } 9738 9739 // DescribeMovingAddressesPagesWithContext indicates an expected call of DescribeMovingAddressesPagesWithContext 9740 func (mr *MockEC2APIMockRecorder) DescribeMovingAddressesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9741 mr.mock.ctrl.T.Helper() 9742 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9743 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeMovingAddressesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeMovingAddressesPagesWithContext), varargs...) 9744 } 9745 9746 // DescribeNatGateways mocks base method 9747 func (m *MockEC2API) DescribeNatGateways(arg0 *ec2.DescribeNatGatewaysInput) (*ec2.DescribeNatGatewaysOutput, error) { 9748 m.ctrl.T.Helper() 9749 ret := m.ctrl.Call(m, "DescribeNatGateways", arg0) 9750 ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput) 9751 ret1, _ := ret[1].(error) 9752 return ret0, ret1 9753 } 9754 9755 // DescribeNatGateways indicates an expected call of DescribeNatGateways 9756 func (mr *MockEC2APIMockRecorder) DescribeNatGateways(arg0 interface{}) *gomock.Call { 9757 mr.mock.ctrl.T.Helper() 9758 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGateways), arg0) 9759 } 9760 9761 // DescribeNatGatewaysWithContext mocks base method 9762 func (m *MockEC2API) DescribeNatGatewaysWithContext(arg0 aws.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.Option) (*ec2.DescribeNatGatewaysOutput, error) { 9763 m.ctrl.T.Helper() 9764 varargs := []interface{}{arg0, arg1} 9765 for _, a := range arg2 { 9766 varargs = append(varargs, a) 9767 } 9768 ret := m.ctrl.Call(m, "DescribeNatGatewaysWithContext", varargs...) 9769 ret0, _ := ret[0].(*ec2.DescribeNatGatewaysOutput) 9770 ret1, _ := ret[1].(error) 9771 return ret0, ret1 9772 } 9773 9774 // DescribeNatGatewaysWithContext indicates an expected call of DescribeNatGatewaysWithContext 9775 func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9776 mr.mock.ctrl.T.Helper() 9777 varargs := append([]interface{}{arg0, arg1}, arg2...) 9778 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysWithContext), varargs...) 9779 } 9780 9781 // DescribeNatGatewaysRequest mocks base method 9782 func (m *MockEC2API) DescribeNatGatewaysRequest(arg0 *ec2.DescribeNatGatewaysInput) (*request.Request, *ec2.DescribeNatGatewaysOutput) { 9783 m.ctrl.T.Helper() 9784 ret := m.ctrl.Call(m, "DescribeNatGatewaysRequest", arg0) 9785 ret0, _ := ret[0].(*request.Request) 9786 ret1, _ := ret[1].(*ec2.DescribeNatGatewaysOutput) 9787 return ret0, ret1 9788 } 9789 9790 // DescribeNatGatewaysRequest indicates an expected call of DescribeNatGatewaysRequest 9791 func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysRequest(arg0 interface{}) *gomock.Call { 9792 mr.mock.ctrl.T.Helper() 9793 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysRequest), arg0) 9794 } 9795 9796 // DescribeNatGatewaysPages mocks base method 9797 func (m *MockEC2API) DescribeNatGatewaysPages(arg0 *ec2.DescribeNatGatewaysInput, arg1 func(*ec2.DescribeNatGatewaysOutput, bool) bool) error { 9798 m.ctrl.T.Helper() 9799 ret := m.ctrl.Call(m, "DescribeNatGatewaysPages", arg0, arg1) 9800 ret0, _ := ret[0].(error) 9801 return ret0 9802 } 9803 9804 // DescribeNatGatewaysPages indicates an expected call of DescribeNatGatewaysPages 9805 func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysPages(arg0, arg1 interface{}) *gomock.Call { 9806 mr.mock.ctrl.T.Helper() 9807 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysPages), arg0, arg1) 9808 } 9809 9810 // DescribeNatGatewaysPagesWithContext mocks base method 9811 func (m *MockEC2API) DescribeNatGatewaysPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 func(*ec2.DescribeNatGatewaysOutput, bool) bool, arg3 ...request.Option) error { 9812 m.ctrl.T.Helper() 9813 varargs := []interface{}{arg0, arg1, arg2} 9814 for _, a := range arg3 { 9815 varargs = append(varargs, a) 9816 } 9817 ret := m.ctrl.Call(m, "DescribeNatGatewaysPagesWithContext", varargs...) 9818 ret0, _ := ret[0].(error) 9819 return ret0 9820 } 9821 9822 // DescribeNatGatewaysPagesWithContext indicates an expected call of DescribeNatGatewaysPagesWithContext 9823 func (mr *MockEC2APIMockRecorder) DescribeNatGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9824 mr.mock.ctrl.T.Helper() 9825 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9826 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNatGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNatGatewaysPagesWithContext), varargs...) 9827 } 9828 9829 // DescribeNetworkAcls mocks base method 9830 func (m *MockEC2API) DescribeNetworkAcls(arg0 *ec2.DescribeNetworkAclsInput) (*ec2.DescribeNetworkAclsOutput, error) { 9831 m.ctrl.T.Helper() 9832 ret := m.ctrl.Call(m, "DescribeNetworkAcls", arg0) 9833 ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput) 9834 ret1, _ := ret[1].(error) 9835 return ret0, ret1 9836 } 9837 9838 // DescribeNetworkAcls indicates an expected call of DescribeNetworkAcls 9839 func (mr *MockEC2APIMockRecorder) DescribeNetworkAcls(arg0 interface{}) *gomock.Call { 9840 mr.mock.ctrl.T.Helper() 9841 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAcls", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAcls), arg0) 9842 } 9843 9844 // DescribeNetworkAclsWithContext mocks base method 9845 func (m *MockEC2API) DescribeNetworkAclsWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 ...request.Option) (*ec2.DescribeNetworkAclsOutput, error) { 9846 m.ctrl.T.Helper() 9847 varargs := []interface{}{arg0, arg1} 9848 for _, a := range arg2 { 9849 varargs = append(varargs, a) 9850 } 9851 ret := m.ctrl.Call(m, "DescribeNetworkAclsWithContext", varargs...) 9852 ret0, _ := ret[0].(*ec2.DescribeNetworkAclsOutput) 9853 ret1, _ := ret[1].(error) 9854 return ret0, ret1 9855 } 9856 9857 // DescribeNetworkAclsWithContext indicates an expected call of DescribeNetworkAclsWithContext 9858 func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9859 mr.mock.ctrl.T.Helper() 9860 varargs := append([]interface{}{arg0, arg1}, arg2...) 9861 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsWithContext), varargs...) 9862 } 9863 9864 // DescribeNetworkAclsRequest mocks base method 9865 func (m *MockEC2API) DescribeNetworkAclsRequest(arg0 *ec2.DescribeNetworkAclsInput) (*request.Request, *ec2.DescribeNetworkAclsOutput) { 9866 m.ctrl.T.Helper() 9867 ret := m.ctrl.Call(m, "DescribeNetworkAclsRequest", arg0) 9868 ret0, _ := ret[0].(*request.Request) 9869 ret1, _ := ret[1].(*ec2.DescribeNetworkAclsOutput) 9870 return ret0, ret1 9871 } 9872 9873 // DescribeNetworkAclsRequest indicates an expected call of DescribeNetworkAclsRequest 9874 func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsRequest(arg0 interface{}) *gomock.Call { 9875 mr.mock.ctrl.T.Helper() 9876 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsRequest), arg0) 9877 } 9878 9879 // DescribeNetworkAclsPages mocks base method 9880 func (m *MockEC2API) DescribeNetworkAclsPages(arg0 *ec2.DescribeNetworkAclsInput, arg1 func(*ec2.DescribeNetworkAclsOutput, bool) bool) error { 9881 m.ctrl.T.Helper() 9882 ret := m.ctrl.Call(m, "DescribeNetworkAclsPages", arg0, arg1) 9883 ret0, _ := ret[0].(error) 9884 return ret0 9885 } 9886 9887 // DescribeNetworkAclsPages indicates an expected call of DescribeNetworkAclsPages 9888 func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsPages(arg0, arg1 interface{}) *gomock.Call { 9889 mr.mock.ctrl.T.Helper() 9890 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsPages), arg0, arg1) 9891 } 9892 9893 // DescribeNetworkAclsPagesWithContext mocks base method 9894 func (m *MockEC2API) DescribeNetworkAclsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkAclsInput, arg2 func(*ec2.DescribeNetworkAclsOutput, bool) bool, arg3 ...request.Option) error { 9895 m.ctrl.T.Helper() 9896 varargs := []interface{}{arg0, arg1, arg2} 9897 for _, a := range arg3 { 9898 varargs = append(varargs, a) 9899 } 9900 ret := m.ctrl.Call(m, "DescribeNetworkAclsPagesWithContext", varargs...) 9901 ret0, _ := ret[0].(error) 9902 return ret0 9903 } 9904 9905 // DescribeNetworkAclsPagesWithContext indicates an expected call of DescribeNetworkAclsPagesWithContext 9906 func (mr *MockEC2APIMockRecorder) DescribeNetworkAclsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 9907 mr.mock.ctrl.T.Helper() 9908 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 9909 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkAclsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkAclsPagesWithContext), varargs...) 9910 } 9911 9912 // DescribeNetworkInterfaceAttribute mocks base method 9913 func (m *MockEC2API) DescribeNetworkInterfaceAttribute(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) { 9914 m.ctrl.T.Helper() 9915 ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttribute", arg0) 9916 ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput) 9917 ret1, _ := ret[1].(error) 9918 return ret0, ret1 9919 } 9920 9921 // DescribeNetworkInterfaceAttribute indicates an expected call of DescribeNetworkInterfaceAttribute 9922 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { 9923 mr.mock.ctrl.T.Helper() 9924 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttribute), arg0) 9925 } 9926 9927 // DescribeNetworkInterfaceAttributeWithContext mocks base method 9928 func (m *MockEC2API) DescribeNetworkInterfaceAttributeWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfaceAttributeOutput, error) { 9929 m.ctrl.T.Helper() 9930 varargs := []interface{}{arg0, arg1} 9931 for _, a := range arg2 { 9932 varargs = append(varargs, a) 9933 } 9934 ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeWithContext", varargs...) 9935 ret0, _ := ret[0].(*ec2.DescribeNetworkInterfaceAttributeOutput) 9936 ret1, _ := ret[1].(error) 9937 return ret0, ret1 9938 } 9939 9940 // DescribeNetworkInterfaceAttributeWithContext indicates an expected call of DescribeNetworkInterfaceAttributeWithContext 9941 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9942 mr.mock.ctrl.T.Helper() 9943 varargs := append([]interface{}{arg0, arg1}, arg2...) 9944 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeWithContext), varargs...) 9945 } 9946 9947 // DescribeNetworkInterfaceAttributeRequest mocks base method 9948 func (m *MockEC2API) DescribeNetworkInterfaceAttributeRequest(arg0 *ec2.DescribeNetworkInterfaceAttributeInput) (*request.Request, *ec2.DescribeNetworkInterfaceAttributeOutput) { 9949 m.ctrl.T.Helper() 9950 ret := m.ctrl.Call(m, "DescribeNetworkInterfaceAttributeRequest", arg0) 9951 ret0, _ := ret[0].(*request.Request) 9952 ret1, _ := ret[1].(*ec2.DescribeNetworkInterfaceAttributeOutput) 9953 return ret0, ret1 9954 } 9955 9956 // DescribeNetworkInterfaceAttributeRequest indicates an expected call of DescribeNetworkInterfaceAttributeRequest 9957 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { 9958 mr.mock.ctrl.T.Helper() 9959 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaceAttributeRequest), arg0) 9960 } 9961 9962 // DescribeNetworkInterfacePermissions mocks base method 9963 func (m *MockEC2API) DescribeNetworkInterfacePermissions(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) { 9964 m.ctrl.T.Helper() 9965 ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissions", arg0) 9966 ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput) 9967 ret1, _ := ret[1].(error) 9968 return ret0, ret1 9969 } 9970 9971 // DescribeNetworkInterfacePermissions indicates an expected call of DescribeNetworkInterfacePermissions 9972 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissions(arg0 interface{}) *gomock.Call { 9973 mr.mock.ctrl.T.Helper() 9974 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissions), arg0) 9975 } 9976 9977 // DescribeNetworkInterfacePermissionsWithContext mocks base method 9978 func (m *MockEC2API) DescribeNetworkInterfacePermissionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacePermissionsOutput, error) { 9979 m.ctrl.T.Helper() 9980 varargs := []interface{}{arg0, arg1} 9981 for _, a := range arg2 { 9982 varargs = append(varargs, a) 9983 } 9984 ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsWithContext", varargs...) 9985 ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacePermissionsOutput) 9986 ret1, _ := ret[1].(error) 9987 return ret0, ret1 9988 } 9989 9990 // DescribeNetworkInterfacePermissionsWithContext indicates an expected call of DescribeNetworkInterfacePermissionsWithContext 9991 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 9992 mr.mock.ctrl.T.Helper() 9993 varargs := append([]interface{}{arg0, arg1}, arg2...) 9994 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsWithContext), varargs...) 9995 } 9996 9997 // DescribeNetworkInterfacePermissionsRequest mocks base method 9998 func (m *MockEC2API) DescribeNetworkInterfacePermissionsRequest(arg0 *ec2.DescribeNetworkInterfacePermissionsInput) (*request.Request, *ec2.DescribeNetworkInterfacePermissionsOutput) { 9999 m.ctrl.T.Helper() 10000 ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsRequest", arg0) 10001 ret0, _ := ret[0].(*request.Request) 10002 ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacePermissionsOutput) 10003 return ret0, ret1 10004 } 10005 10006 // DescribeNetworkInterfacePermissionsRequest indicates an expected call of DescribeNetworkInterfacePermissionsRequest 10007 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsRequest(arg0 interface{}) *gomock.Call { 10008 mr.mock.ctrl.T.Helper() 10009 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsRequest), arg0) 10010 } 10011 10012 // DescribeNetworkInterfacePermissionsPages mocks base method 10013 func (m *MockEC2API) DescribeNetworkInterfacePermissionsPages(arg0 *ec2.DescribeNetworkInterfacePermissionsInput, arg1 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool) error { 10014 m.ctrl.T.Helper() 10015 ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsPages", arg0, arg1) 10016 ret0, _ := ret[0].(error) 10017 return ret0 10018 } 10019 10020 // DescribeNetworkInterfacePermissionsPages indicates an expected call of DescribeNetworkInterfacePermissionsPages 10021 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsPages(arg0, arg1 interface{}) *gomock.Call { 10022 mr.mock.ctrl.T.Helper() 10023 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPages), arg0, arg1) 10024 } 10025 10026 // DescribeNetworkInterfacePermissionsPagesWithContext mocks base method 10027 func (m *MockEC2API) DescribeNetworkInterfacePermissionsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInterfacePermissionsInput, arg2 func(*ec2.DescribeNetworkInterfacePermissionsOutput, bool) bool, arg3 ...request.Option) error { 10028 m.ctrl.T.Helper() 10029 varargs := []interface{}{arg0, arg1, arg2} 10030 for _, a := range arg3 { 10031 varargs = append(varargs, a) 10032 } 10033 ret := m.ctrl.Call(m, "DescribeNetworkInterfacePermissionsPagesWithContext", varargs...) 10034 ret0, _ := ret[0].(error) 10035 return ret0 10036 } 10037 10038 // DescribeNetworkInterfacePermissionsPagesWithContext indicates an expected call of DescribeNetworkInterfacePermissionsPagesWithContext 10039 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacePermissionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10040 mr.mock.ctrl.T.Helper() 10041 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10042 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacePermissionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacePermissionsPagesWithContext), varargs...) 10043 } 10044 10045 // DescribeNetworkInterfaces mocks base method 10046 func (m *MockEC2API) DescribeNetworkInterfaces(arg0 *ec2.DescribeNetworkInterfacesInput) (*ec2.DescribeNetworkInterfacesOutput, error) { 10047 m.ctrl.T.Helper() 10048 ret := m.ctrl.Call(m, "DescribeNetworkInterfaces", arg0) 10049 ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput) 10050 ret1, _ := ret[1].(error) 10051 return ret0, ret1 10052 } 10053 10054 // DescribeNetworkInterfaces indicates an expected call of DescribeNetworkInterfaces 10055 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfaces(arg0 interface{}) *gomock.Call { 10056 mr.mock.ctrl.T.Helper() 10057 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfaces", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfaces), arg0) 10058 } 10059 10060 // DescribeNetworkInterfacesWithContext mocks base method 10061 func (m *MockEC2API) DescribeNetworkInterfacesWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...request.Option) (*ec2.DescribeNetworkInterfacesOutput, error) { 10062 m.ctrl.T.Helper() 10063 varargs := []interface{}{arg0, arg1} 10064 for _, a := range arg2 { 10065 varargs = append(varargs, a) 10066 } 10067 ret := m.ctrl.Call(m, "DescribeNetworkInterfacesWithContext", varargs...) 10068 ret0, _ := ret[0].(*ec2.DescribeNetworkInterfacesOutput) 10069 ret1, _ := ret[1].(error) 10070 return ret0, ret1 10071 } 10072 10073 // DescribeNetworkInterfacesWithContext indicates an expected call of DescribeNetworkInterfacesWithContext 10074 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10075 mr.mock.ctrl.T.Helper() 10076 varargs := append([]interface{}{arg0, arg1}, arg2...) 10077 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesWithContext), varargs...) 10078 } 10079 10080 // DescribeNetworkInterfacesRequest mocks base method 10081 func (m *MockEC2API) DescribeNetworkInterfacesRequest(arg0 *ec2.DescribeNetworkInterfacesInput) (*request.Request, *ec2.DescribeNetworkInterfacesOutput) { 10082 m.ctrl.T.Helper() 10083 ret := m.ctrl.Call(m, "DescribeNetworkInterfacesRequest", arg0) 10084 ret0, _ := ret[0].(*request.Request) 10085 ret1, _ := ret[1].(*ec2.DescribeNetworkInterfacesOutput) 10086 return ret0, ret1 10087 } 10088 10089 // DescribeNetworkInterfacesRequest indicates an expected call of DescribeNetworkInterfacesRequest 10090 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesRequest(arg0 interface{}) *gomock.Call { 10091 mr.mock.ctrl.T.Helper() 10092 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesRequest), arg0) 10093 } 10094 10095 // DescribeNetworkInterfacesPages mocks base method 10096 func (m *MockEC2API) DescribeNetworkInterfacesPages(arg0 *ec2.DescribeNetworkInterfacesInput, arg1 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool) error { 10097 m.ctrl.T.Helper() 10098 ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPages", arg0, arg1) 10099 ret0, _ := ret[0].(error) 10100 return ret0 10101 } 10102 10103 // DescribeNetworkInterfacesPages indicates an expected call of DescribeNetworkInterfacesPages 10104 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesPages(arg0, arg1 interface{}) *gomock.Call { 10105 mr.mock.ctrl.T.Helper() 10106 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesPages), arg0, arg1) 10107 } 10108 10109 // DescribeNetworkInterfacesPagesWithContext mocks base method 10110 func (m *MockEC2API) DescribeNetworkInterfacesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 func(*ec2.DescribeNetworkInterfacesOutput, bool) bool, arg3 ...request.Option) error { 10111 m.ctrl.T.Helper() 10112 varargs := []interface{}{arg0, arg1, arg2} 10113 for _, a := range arg3 { 10114 varargs = append(varargs, a) 10115 } 10116 ret := m.ctrl.Call(m, "DescribeNetworkInterfacesPagesWithContext", varargs...) 10117 ret0, _ := ret[0].(error) 10118 return ret0 10119 } 10120 10121 // DescribeNetworkInterfacesPagesWithContext indicates an expected call of DescribeNetworkInterfacesPagesWithContext 10122 func (mr *MockEC2APIMockRecorder) DescribeNetworkInterfacesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10123 mr.mock.ctrl.T.Helper() 10124 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10125 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeNetworkInterfacesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeNetworkInterfacesPagesWithContext), varargs...) 10126 } 10127 10128 // DescribePlacementGroups mocks base method 10129 func (m *MockEC2API) DescribePlacementGroups(arg0 *ec2.DescribePlacementGroupsInput) (*ec2.DescribePlacementGroupsOutput, error) { 10130 m.ctrl.T.Helper() 10131 ret := m.ctrl.Call(m, "DescribePlacementGroups", arg0) 10132 ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput) 10133 ret1, _ := ret[1].(error) 10134 return ret0, ret1 10135 } 10136 10137 // DescribePlacementGroups indicates an expected call of DescribePlacementGroups 10138 func (mr *MockEC2APIMockRecorder) DescribePlacementGroups(arg0 interface{}) *gomock.Call { 10139 mr.mock.ctrl.T.Helper() 10140 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroups", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroups), arg0) 10141 } 10142 10143 // DescribePlacementGroupsWithContext mocks base method 10144 func (m *MockEC2API) DescribePlacementGroupsWithContext(arg0 aws.Context, arg1 *ec2.DescribePlacementGroupsInput, arg2 ...request.Option) (*ec2.DescribePlacementGroupsOutput, error) { 10145 m.ctrl.T.Helper() 10146 varargs := []interface{}{arg0, arg1} 10147 for _, a := range arg2 { 10148 varargs = append(varargs, a) 10149 } 10150 ret := m.ctrl.Call(m, "DescribePlacementGroupsWithContext", varargs...) 10151 ret0, _ := ret[0].(*ec2.DescribePlacementGroupsOutput) 10152 ret1, _ := ret[1].(error) 10153 return ret0, ret1 10154 } 10155 10156 // DescribePlacementGroupsWithContext indicates an expected call of DescribePlacementGroupsWithContext 10157 func (mr *MockEC2APIMockRecorder) DescribePlacementGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10158 mr.mock.ctrl.T.Helper() 10159 varargs := append([]interface{}{arg0, arg1}, arg2...) 10160 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroupsWithContext), varargs...) 10161 } 10162 10163 // DescribePlacementGroupsRequest mocks base method 10164 func (m *MockEC2API) DescribePlacementGroupsRequest(arg0 *ec2.DescribePlacementGroupsInput) (*request.Request, *ec2.DescribePlacementGroupsOutput) { 10165 m.ctrl.T.Helper() 10166 ret := m.ctrl.Call(m, "DescribePlacementGroupsRequest", arg0) 10167 ret0, _ := ret[0].(*request.Request) 10168 ret1, _ := ret[1].(*ec2.DescribePlacementGroupsOutput) 10169 return ret0, ret1 10170 } 10171 10172 // DescribePlacementGroupsRequest indicates an expected call of DescribePlacementGroupsRequest 10173 func (mr *MockEC2APIMockRecorder) DescribePlacementGroupsRequest(arg0 interface{}) *gomock.Call { 10174 mr.mock.ctrl.T.Helper() 10175 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePlacementGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePlacementGroupsRequest), arg0) 10176 } 10177 10178 // DescribePrefixLists mocks base method 10179 func (m *MockEC2API) DescribePrefixLists(arg0 *ec2.DescribePrefixListsInput) (*ec2.DescribePrefixListsOutput, error) { 10180 m.ctrl.T.Helper() 10181 ret := m.ctrl.Call(m, "DescribePrefixLists", arg0) 10182 ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput) 10183 ret1, _ := ret[1].(error) 10184 return ret0, ret1 10185 } 10186 10187 // DescribePrefixLists indicates an expected call of DescribePrefixLists 10188 func (mr *MockEC2APIMockRecorder) DescribePrefixLists(arg0 interface{}) *gomock.Call { 10189 mr.mock.ctrl.T.Helper() 10190 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixLists", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixLists), arg0) 10191 } 10192 10193 // DescribePrefixListsWithContext mocks base method 10194 func (m *MockEC2API) DescribePrefixListsWithContext(arg0 aws.Context, arg1 *ec2.DescribePrefixListsInput, arg2 ...request.Option) (*ec2.DescribePrefixListsOutput, error) { 10195 m.ctrl.T.Helper() 10196 varargs := []interface{}{arg0, arg1} 10197 for _, a := range arg2 { 10198 varargs = append(varargs, a) 10199 } 10200 ret := m.ctrl.Call(m, "DescribePrefixListsWithContext", varargs...) 10201 ret0, _ := ret[0].(*ec2.DescribePrefixListsOutput) 10202 ret1, _ := ret[1].(error) 10203 return ret0, ret1 10204 } 10205 10206 // DescribePrefixListsWithContext indicates an expected call of DescribePrefixListsWithContext 10207 func (mr *MockEC2APIMockRecorder) DescribePrefixListsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10208 mr.mock.ctrl.T.Helper() 10209 varargs := append([]interface{}{arg0, arg1}, arg2...) 10210 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsWithContext), varargs...) 10211 } 10212 10213 // DescribePrefixListsRequest mocks base method 10214 func (m *MockEC2API) DescribePrefixListsRequest(arg0 *ec2.DescribePrefixListsInput) (*request.Request, *ec2.DescribePrefixListsOutput) { 10215 m.ctrl.T.Helper() 10216 ret := m.ctrl.Call(m, "DescribePrefixListsRequest", arg0) 10217 ret0, _ := ret[0].(*request.Request) 10218 ret1, _ := ret[1].(*ec2.DescribePrefixListsOutput) 10219 return ret0, ret1 10220 } 10221 10222 // DescribePrefixListsRequest indicates an expected call of DescribePrefixListsRequest 10223 func (mr *MockEC2APIMockRecorder) DescribePrefixListsRequest(arg0 interface{}) *gomock.Call { 10224 mr.mock.ctrl.T.Helper() 10225 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsRequest), arg0) 10226 } 10227 10228 // DescribePrefixListsPages mocks base method 10229 func (m *MockEC2API) DescribePrefixListsPages(arg0 *ec2.DescribePrefixListsInput, arg1 func(*ec2.DescribePrefixListsOutput, bool) bool) error { 10230 m.ctrl.T.Helper() 10231 ret := m.ctrl.Call(m, "DescribePrefixListsPages", arg0, arg1) 10232 ret0, _ := ret[0].(error) 10233 return ret0 10234 } 10235 10236 // DescribePrefixListsPages indicates an expected call of DescribePrefixListsPages 10237 func (mr *MockEC2APIMockRecorder) DescribePrefixListsPages(arg0, arg1 interface{}) *gomock.Call { 10238 mr.mock.ctrl.T.Helper() 10239 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsPages), arg0, arg1) 10240 } 10241 10242 // DescribePrefixListsPagesWithContext mocks base method 10243 func (m *MockEC2API) DescribePrefixListsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribePrefixListsInput, arg2 func(*ec2.DescribePrefixListsOutput, bool) bool, arg3 ...request.Option) error { 10244 m.ctrl.T.Helper() 10245 varargs := []interface{}{arg0, arg1, arg2} 10246 for _, a := range arg3 { 10247 varargs = append(varargs, a) 10248 } 10249 ret := m.ctrl.Call(m, "DescribePrefixListsPagesWithContext", varargs...) 10250 ret0, _ := ret[0].(error) 10251 return ret0 10252 } 10253 10254 // DescribePrefixListsPagesWithContext indicates an expected call of DescribePrefixListsPagesWithContext 10255 func (mr *MockEC2APIMockRecorder) DescribePrefixListsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10256 mr.mock.ctrl.T.Helper() 10257 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10258 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrefixListsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrefixListsPagesWithContext), varargs...) 10259 } 10260 10261 // DescribePrincipalIdFormat mocks base method 10262 func (m *MockEC2API) DescribePrincipalIdFormat(arg0 *ec2.DescribePrincipalIdFormatInput) (*ec2.DescribePrincipalIdFormatOutput, error) { 10263 m.ctrl.T.Helper() 10264 ret := m.ctrl.Call(m, "DescribePrincipalIdFormat", arg0) 10265 ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput) 10266 ret1, _ := ret[1].(error) 10267 return ret0, ret1 10268 } 10269 10270 // DescribePrincipalIdFormat indicates an expected call of DescribePrincipalIdFormat 10271 func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormat(arg0 interface{}) *gomock.Call { 10272 mr.mock.ctrl.T.Helper() 10273 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormat", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormat), arg0) 10274 } 10275 10276 // DescribePrincipalIdFormatWithContext mocks base method 10277 func (m *MockEC2API) DescribePrincipalIdFormatWithContext(arg0 aws.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 ...request.Option) (*ec2.DescribePrincipalIdFormatOutput, error) { 10278 m.ctrl.T.Helper() 10279 varargs := []interface{}{arg0, arg1} 10280 for _, a := range arg2 { 10281 varargs = append(varargs, a) 10282 } 10283 ret := m.ctrl.Call(m, "DescribePrincipalIdFormatWithContext", varargs...) 10284 ret0, _ := ret[0].(*ec2.DescribePrincipalIdFormatOutput) 10285 ret1, _ := ret[1].(error) 10286 return ret0, ret1 10287 } 10288 10289 // DescribePrincipalIdFormatWithContext indicates an expected call of DescribePrincipalIdFormatWithContext 10290 func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10291 mr.mock.ctrl.T.Helper() 10292 varargs := append([]interface{}{arg0, arg1}, arg2...) 10293 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatWithContext), varargs...) 10294 } 10295 10296 // DescribePrincipalIdFormatRequest mocks base method 10297 func (m *MockEC2API) DescribePrincipalIdFormatRequest(arg0 *ec2.DescribePrincipalIdFormatInput) (*request.Request, *ec2.DescribePrincipalIdFormatOutput) { 10298 m.ctrl.T.Helper() 10299 ret := m.ctrl.Call(m, "DescribePrincipalIdFormatRequest", arg0) 10300 ret0, _ := ret[0].(*request.Request) 10301 ret1, _ := ret[1].(*ec2.DescribePrincipalIdFormatOutput) 10302 return ret0, ret1 10303 } 10304 10305 // DescribePrincipalIdFormatRequest indicates an expected call of DescribePrincipalIdFormatRequest 10306 func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatRequest(arg0 interface{}) *gomock.Call { 10307 mr.mock.ctrl.T.Helper() 10308 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatRequest), arg0) 10309 } 10310 10311 // DescribePrincipalIdFormatPages mocks base method 10312 func (m *MockEC2API) DescribePrincipalIdFormatPages(arg0 *ec2.DescribePrincipalIdFormatInput, arg1 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool) error { 10313 m.ctrl.T.Helper() 10314 ret := m.ctrl.Call(m, "DescribePrincipalIdFormatPages", arg0, arg1) 10315 ret0, _ := ret[0].(error) 10316 return ret0 10317 } 10318 10319 // DescribePrincipalIdFormatPages indicates an expected call of DescribePrincipalIdFormatPages 10320 func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatPages(arg0, arg1 interface{}) *gomock.Call { 10321 mr.mock.ctrl.T.Helper() 10322 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatPages", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatPages), arg0, arg1) 10323 } 10324 10325 // DescribePrincipalIdFormatPagesWithContext mocks base method 10326 func (m *MockEC2API) DescribePrincipalIdFormatPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribePrincipalIdFormatInput, arg2 func(*ec2.DescribePrincipalIdFormatOutput, bool) bool, arg3 ...request.Option) error { 10327 m.ctrl.T.Helper() 10328 varargs := []interface{}{arg0, arg1, arg2} 10329 for _, a := range arg3 { 10330 varargs = append(varargs, a) 10331 } 10332 ret := m.ctrl.Call(m, "DescribePrincipalIdFormatPagesWithContext", varargs...) 10333 ret0, _ := ret[0].(error) 10334 return ret0 10335 } 10336 10337 // DescribePrincipalIdFormatPagesWithContext indicates an expected call of DescribePrincipalIdFormatPagesWithContext 10338 func (mr *MockEC2APIMockRecorder) DescribePrincipalIdFormatPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10339 mr.mock.ctrl.T.Helper() 10340 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10341 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePrincipalIdFormatPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePrincipalIdFormatPagesWithContext), varargs...) 10342 } 10343 10344 // DescribePublicIpv4Pools mocks base method 10345 func (m *MockEC2API) DescribePublicIpv4Pools(arg0 *ec2.DescribePublicIpv4PoolsInput) (*ec2.DescribePublicIpv4PoolsOutput, error) { 10346 m.ctrl.T.Helper() 10347 ret := m.ctrl.Call(m, "DescribePublicIpv4Pools", arg0) 10348 ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput) 10349 ret1, _ := ret[1].(error) 10350 return ret0, ret1 10351 } 10352 10353 // DescribePublicIpv4Pools indicates an expected call of DescribePublicIpv4Pools 10354 func (mr *MockEC2APIMockRecorder) DescribePublicIpv4Pools(arg0 interface{}) *gomock.Call { 10355 mr.mock.ctrl.T.Helper() 10356 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4Pools", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4Pools), arg0) 10357 } 10358 10359 // DescribePublicIpv4PoolsWithContext mocks base method 10360 func (m *MockEC2API) DescribePublicIpv4PoolsWithContext(arg0 aws.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 ...request.Option) (*ec2.DescribePublicIpv4PoolsOutput, error) { 10361 m.ctrl.T.Helper() 10362 varargs := []interface{}{arg0, arg1} 10363 for _, a := range arg2 { 10364 varargs = append(varargs, a) 10365 } 10366 ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsWithContext", varargs...) 10367 ret0, _ := ret[0].(*ec2.DescribePublicIpv4PoolsOutput) 10368 ret1, _ := ret[1].(error) 10369 return ret0, ret1 10370 } 10371 10372 // DescribePublicIpv4PoolsWithContext indicates an expected call of DescribePublicIpv4PoolsWithContext 10373 func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10374 mr.mock.ctrl.T.Helper() 10375 varargs := append([]interface{}{arg0, arg1}, arg2...) 10376 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsWithContext), varargs...) 10377 } 10378 10379 // DescribePublicIpv4PoolsRequest mocks base method 10380 func (m *MockEC2API) DescribePublicIpv4PoolsRequest(arg0 *ec2.DescribePublicIpv4PoolsInput) (*request.Request, *ec2.DescribePublicIpv4PoolsOutput) { 10381 m.ctrl.T.Helper() 10382 ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsRequest", arg0) 10383 ret0, _ := ret[0].(*request.Request) 10384 ret1, _ := ret[1].(*ec2.DescribePublicIpv4PoolsOutput) 10385 return ret0, ret1 10386 } 10387 10388 // DescribePublicIpv4PoolsRequest indicates an expected call of DescribePublicIpv4PoolsRequest 10389 func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsRequest(arg0 interface{}) *gomock.Call { 10390 mr.mock.ctrl.T.Helper() 10391 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsRequest), arg0) 10392 } 10393 10394 // DescribePublicIpv4PoolsPages mocks base method 10395 func (m *MockEC2API) DescribePublicIpv4PoolsPages(arg0 *ec2.DescribePublicIpv4PoolsInput, arg1 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool) error { 10396 m.ctrl.T.Helper() 10397 ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsPages", arg0, arg1) 10398 ret0, _ := ret[0].(error) 10399 return ret0 10400 } 10401 10402 // DescribePublicIpv4PoolsPages indicates an expected call of DescribePublicIpv4PoolsPages 10403 func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsPages(arg0, arg1 interface{}) *gomock.Call { 10404 mr.mock.ctrl.T.Helper() 10405 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsPages", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsPages), arg0, arg1) 10406 } 10407 10408 // DescribePublicIpv4PoolsPagesWithContext mocks base method 10409 func (m *MockEC2API) DescribePublicIpv4PoolsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribePublicIpv4PoolsInput, arg2 func(*ec2.DescribePublicIpv4PoolsOutput, bool) bool, arg3 ...request.Option) error { 10410 m.ctrl.T.Helper() 10411 varargs := []interface{}{arg0, arg1, arg2} 10412 for _, a := range arg3 { 10413 varargs = append(varargs, a) 10414 } 10415 ret := m.ctrl.Call(m, "DescribePublicIpv4PoolsPagesWithContext", varargs...) 10416 ret0, _ := ret[0].(error) 10417 return ret0 10418 } 10419 10420 // DescribePublicIpv4PoolsPagesWithContext indicates an expected call of DescribePublicIpv4PoolsPagesWithContext 10421 func (mr *MockEC2APIMockRecorder) DescribePublicIpv4PoolsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10422 mr.mock.ctrl.T.Helper() 10423 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10424 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribePublicIpv4PoolsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribePublicIpv4PoolsPagesWithContext), varargs...) 10425 } 10426 10427 // DescribeRegions mocks base method 10428 func (m *MockEC2API) DescribeRegions(arg0 *ec2.DescribeRegionsInput) (*ec2.DescribeRegionsOutput, error) { 10429 m.ctrl.T.Helper() 10430 ret := m.ctrl.Call(m, "DescribeRegions", arg0) 10431 ret0, _ := ret[0].(*ec2.DescribeRegionsOutput) 10432 ret1, _ := ret[1].(error) 10433 return ret0, ret1 10434 } 10435 10436 // DescribeRegions indicates an expected call of DescribeRegions 10437 func (mr *MockEC2APIMockRecorder) DescribeRegions(arg0 interface{}) *gomock.Call { 10438 mr.mock.ctrl.T.Helper() 10439 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegions", reflect.TypeOf((*MockEC2API)(nil).DescribeRegions), arg0) 10440 } 10441 10442 // DescribeRegionsWithContext mocks base method 10443 func (m *MockEC2API) DescribeRegionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeRegionsInput, arg2 ...request.Option) (*ec2.DescribeRegionsOutput, error) { 10444 m.ctrl.T.Helper() 10445 varargs := []interface{}{arg0, arg1} 10446 for _, a := range arg2 { 10447 varargs = append(varargs, a) 10448 } 10449 ret := m.ctrl.Call(m, "DescribeRegionsWithContext", varargs...) 10450 ret0, _ := ret[0].(*ec2.DescribeRegionsOutput) 10451 ret1, _ := ret[1].(error) 10452 return ret0, ret1 10453 } 10454 10455 // DescribeRegionsWithContext indicates an expected call of DescribeRegionsWithContext 10456 func (mr *MockEC2APIMockRecorder) DescribeRegionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10457 mr.mock.ctrl.T.Helper() 10458 varargs := append([]interface{}{arg0, arg1}, arg2...) 10459 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsWithContext), varargs...) 10460 } 10461 10462 // DescribeRegionsRequest mocks base method 10463 func (m *MockEC2API) DescribeRegionsRequest(arg0 *ec2.DescribeRegionsInput) (*request.Request, *ec2.DescribeRegionsOutput) { 10464 m.ctrl.T.Helper() 10465 ret := m.ctrl.Call(m, "DescribeRegionsRequest", arg0) 10466 ret0, _ := ret[0].(*request.Request) 10467 ret1, _ := ret[1].(*ec2.DescribeRegionsOutput) 10468 return ret0, ret1 10469 } 10470 10471 // DescribeRegionsRequest indicates an expected call of DescribeRegionsRequest 10472 func (mr *MockEC2APIMockRecorder) DescribeRegionsRequest(arg0 interface{}) *gomock.Call { 10473 mr.mock.ctrl.T.Helper() 10474 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRegionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRegionsRequest), arg0) 10475 } 10476 10477 // DescribeReservedInstances mocks base method 10478 func (m *MockEC2API) DescribeReservedInstances(arg0 *ec2.DescribeReservedInstancesInput) (*ec2.DescribeReservedInstancesOutput, error) { 10479 m.ctrl.T.Helper() 10480 ret := m.ctrl.Call(m, "DescribeReservedInstances", arg0) 10481 ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput) 10482 ret1, _ := ret[1].(error) 10483 return ret0, ret1 10484 } 10485 10486 // DescribeReservedInstances indicates an expected call of DescribeReservedInstances 10487 func (mr *MockEC2APIMockRecorder) DescribeReservedInstances(arg0 interface{}) *gomock.Call { 10488 mr.mock.ctrl.T.Helper() 10489 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstances), arg0) 10490 } 10491 10492 // DescribeReservedInstancesWithContext mocks base method 10493 func (m *MockEC2API) DescribeReservedInstancesWithContext(arg0 aws.Context, arg1 *ec2.DescribeReservedInstancesInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOutput, error) { 10494 m.ctrl.T.Helper() 10495 varargs := []interface{}{arg0, arg1} 10496 for _, a := range arg2 { 10497 varargs = append(varargs, a) 10498 } 10499 ret := m.ctrl.Call(m, "DescribeReservedInstancesWithContext", varargs...) 10500 ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOutput) 10501 ret1, _ := ret[1].(error) 10502 return ret0, ret1 10503 } 10504 10505 // DescribeReservedInstancesWithContext indicates an expected call of DescribeReservedInstancesWithContext 10506 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10507 mr.mock.ctrl.T.Helper() 10508 varargs := append([]interface{}{arg0, arg1}, arg2...) 10509 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesWithContext), varargs...) 10510 } 10511 10512 // DescribeReservedInstancesRequest mocks base method 10513 func (m *MockEC2API) DescribeReservedInstancesRequest(arg0 *ec2.DescribeReservedInstancesInput) (*request.Request, *ec2.DescribeReservedInstancesOutput) { 10514 m.ctrl.T.Helper() 10515 ret := m.ctrl.Call(m, "DescribeReservedInstancesRequest", arg0) 10516 ret0, _ := ret[0].(*request.Request) 10517 ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOutput) 10518 return ret0, ret1 10519 } 10520 10521 // DescribeReservedInstancesRequest indicates an expected call of DescribeReservedInstancesRequest 10522 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesRequest(arg0 interface{}) *gomock.Call { 10523 mr.mock.ctrl.T.Helper() 10524 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesRequest), arg0) 10525 } 10526 10527 // DescribeReservedInstancesListings mocks base method 10528 func (m *MockEC2API) DescribeReservedInstancesListings(arg0 *ec2.DescribeReservedInstancesListingsInput) (*ec2.DescribeReservedInstancesListingsOutput, error) { 10529 m.ctrl.T.Helper() 10530 ret := m.ctrl.Call(m, "DescribeReservedInstancesListings", arg0) 10531 ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput) 10532 ret1, _ := ret[1].(error) 10533 return ret0, ret1 10534 } 10535 10536 // DescribeReservedInstancesListings indicates an expected call of DescribeReservedInstancesListings 10537 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListings(arg0 interface{}) *gomock.Call { 10538 mr.mock.ctrl.T.Helper() 10539 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListings), arg0) 10540 } 10541 10542 // DescribeReservedInstancesListingsWithContext mocks base method 10543 func (m *MockEC2API) DescribeReservedInstancesListingsWithContext(arg0 aws.Context, arg1 *ec2.DescribeReservedInstancesListingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesListingsOutput, error) { 10544 m.ctrl.T.Helper() 10545 varargs := []interface{}{arg0, arg1} 10546 for _, a := range arg2 { 10547 varargs = append(varargs, a) 10548 } 10549 ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsWithContext", varargs...) 10550 ret0, _ := ret[0].(*ec2.DescribeReservedInstancesListingsOutput) 10551 ret1, _ := ret[1].(error) 10552 return ret0, ret1 10553 } 10554 10555 // DescribeReservedInstancesListingsWithContext indicates an expected call of DescribeReservedInstancesListingsWithContext 10556 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10557 mr.mock.ctrl.T.Helper() 10558 varargs := append([]interface{}{arg0, arg1}, arg2...) 10559 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListingsWithContext), varargs...) 10560 } 10561 10562 // DescribeReservedInstancesListingsRequest mocks base method 10563 func (m *MockEC2API) DescribeReservedInstancesListingsRequest(arg0 *ec2.DescribeReservedInstancesListingsInput) (*request.Request, *ec2.DescribeReservedInstancesListingsOutput) { 10564 m.ctrl.T.Helper() 10565 ret := m.ctrl.Call(m, "DescribeReservedInstancesListingsRequest", arg0) 10566 ret0, _ := ret[0].(*request.Request) 10567 ret1, _ := ret[1].(*ec2.DescribeReservedInstancesListingsOutput) 10568 return ret0, ret1 10569 } 10570 10571 // DescribeReservedInstancesListingsRequest indicates an expected call of DescribeReservedInstancesListingsRequest 10572 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesListingsRequest(arg0 interface{}) *gomock.Call { 10573 mr.mock.ctrl.T.Helper() 10574 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesListingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesListingsRequest), arg0) 10575 } 10576 10577 // DescribeReservedInstancesModifications mocks base method 10578 func (m *MockEC2API) DescribeReservedInstancesModifications(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*ec2.DescribeReservedInstancesModificationsOutput, error) { 10579 m.ctrl.T.Helper() 10580 ret := m.ctrl.Call(m, "DescribeReservedInstancesModifications", arg0) 10581 ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput) 10582 ret1, _ := ret[1].(error) 10583 return ret0, ret1 10584 } 10585 10586 // DescribeReservedInstancesModifications indicates an expected call of DescribeReservedInstancesModifications 10587 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModifications(arg0 interface{}) *gomock.Call { 10588 mr.mock.ctrl.T.Helper() 10589 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModifications), arg0) 10590 } 10591 10592 // DescribeReservedInstancesModificationsWithContext mocks base method 10593 func (m *MockEC2API) DescribeReservedInstancesModificationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesModificationsOutput, error) { 10594 m.ctrl.T.Helper() 10595 varargs := []interface{}{arg0, arg1} 10596 for _, a := range arg2 { 10597 varargs = append(varargs, a) 10598 } 10599 ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsWithContext", varargs...) 10600 ret0, _ := ret[0].(*ec2.DescribeReservedInstancesModificationsOutput) 10601 ret1, _ := ret[1].(error) 10602 return ret0, ret1 10603 } 10604 10605 // DescribeReservedInstancesModificationsWithContext indicates an expected call of DescribeReservedInstancesModificationsWithContext 10606 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10607 mr.mock.ctrl.T.Helper() 10608 varargs := append([]interface{}{arg0, arg1}, arg2...) 10609 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsWithContext), varargs...) 10610 } 10611 10612 // DescribeReservedInstancesModificationsRequest mocks base method 10613 func (m *MockEC2API) DescribeReservedInstancesModificationsRequest(arg0 *ec2.DescribeReservedInstancesModificationsInput) (*request.Request, *ec2.DescribeReservedInstancesModificationsOutput) { 10614 m.ctrl.T.Helper() 10615 ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsRequest", arg0) 10616 ret0, _ := ret[0].(*request.Request) 10617 ret1, _ := ret[1].(*ec2.DescribeReservedInstancesModificationsOutput) 10618 return ret0, ret1 10619 } 10620 10621 // DescribeReservedInstancesModificationsRequest indicates an expected call of DescribeReservedInstancesModificationsRequest 10622 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsRequest(arg0 interface{}) *gomock.Call { 10623 mr.mock.ctrl.T.Helper() 10624 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsRequest), arg0) 10625 } 10626 10627 // DescribeReservedInstancesModificationsPages mocks base method 10628 func (m *MockEC2API) DescribeReservedInstancesModificationsPages(arg0 *ec2.DescribeReservedInstancesModificationsInput, arg1 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool) error { 10629 m.ctrl.T.Helper() 10630 ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsPages", arg0, arg1) 10631 ret0, _ := ret[0].(error) 10632 return ret0 10633 } 10634 10635 // DescribeReservedInstancesModificationsPages indicates an expected call of DescribeReservedInstancesModificationsPages 10636 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsPages(arg0, arg1 interface{}) *gomock.Call { 10637 mr.mock.ctrl.T.Helper() 10638 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsPages), arg0, arg1) 10639 } 10640 10641 // DescribeReservedInstancesModificationsPagesWithContext mocks base method 10642 func (m *MockEC2API) DescribeReservedInstancesModificationsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeReservedInstancesModificationsInput, arg2 func(*ec2.DescribeReservedInstancesModificationsOutput, bool) bool, arg3 ...request.Option) error { 10643 m.ctrl.T.Helper() 10644 varargs := []interface{}{arg0, arg1, arg2} 10645 for _, a := range arg3 { 10646 varargs = append(varargs, a) 10647 } 10648 ret := m.ctrl.Call(m, "DescribeReservedInstancesModificationsPagesWithContext", varargs...) 10649 ret0, _ := ret[0].(error) 10650 return ret0 10651 } 10652 10653 // DescribeReservedInstancesModificationsPagesWithContext indicates an expected call of DescribeReservedInstancesModificationsPagesWithContext 10654 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesModificationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10655 mr.mock.ctrl.T.Helper() 10656 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10657 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesModificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesModificationsPagesWithContext), varargs...) 10658 } 10659 10660 // DescribeReservedInstancesOfferings mocks base method 10661 func (m *MockEC2API) DescribeReservedInstancesOfferings(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*ec2.DescribeReservedInstancesOfferingsOutput, error) { 10662 m.ctrl.T.Helper() 10663 ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferings", arg0) 10664 ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput) 10665 ret1, _ := ret[1].(error) 10666 return ret0, ret1 10667 } 10668 10669 // DescribeReservedInstancesOfferings indicates an expected call of DescribeReservedInstancesOfferings 10670 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferings(arg0 interface{}) *gomock.Call { 10671 mr.mock.ctrl.T.Helper() 10672 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferings", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferings), arg0) 10673 } 10674 10675 // DescribeReservedInstancesOfferingsWithContext mocks base method 10676 func (m *MockEC2API) DescribeReservedInstancesOfferingsWithContext(arg0 aws.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 ...request.Option) (*ec2.DescribeReservedInstancesOfferingsOutput, error) { 10677 m.ctrl.T.Helper() 10678 varargs := []interface{}{arg0, arg1} 10679 for _, a := range arg2 { 10680 varargs = append(varargs, a) 10681 } 10682 ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsWithContext", varargs...) 10683 ret0, _ := ret[0].(*ec2.DescribeReservedInstancesOfferingsOutput) 10684 ret1, _ := ret[1].(error) 10685 return ret0, ret1 10686 } 10687 10688 // DescribeReservedInstancesOfferingsWithContext indicates an expected call of DescribeReservedInstancesOfferingsWithContext 10689 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10690 mr.mock.ctrl.T.Helper() 10691 varargs := append([]interface{}{arg0, arg1}, arg2...) 10692 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsWithContext), varargs...) 10693 } 10694 10695 // DescribeReservedInstancesOfferingsRequest mocks base method 10696 func (m *MockEC2API) DescribeReservedInstancesOfferingsRequest(arg0 *ec2.DescribeReservedInstancesOfferingsInput) (*request.Request, *ec2.DescribeReservedInstancesOfferingsOutput) { 10697 m.ctrl.T.Helper() 10698 ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsRequest", arg0) 10699 ret0, _ := ret[0].(*request.Request) 10700 ret1, _ := ret[1].(*ec2.DescribeReservedInstancesOfferingsOutput) 10701 return ret0, ret1 10702 } 10703 10704 // DescribeReservedInstancesOfferingsRequest indicates an expected call of DescribeReservedInstancesOfferingsRequest 10705 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsRequest(arg0 interface{}) *gomock.Call { 10706 mr.mock.ctrl.T.Helper() 10707 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsRequest), arg0) 10708 } 10709 10710 // DescribeReservedInstancesOfferingsPages mocks base method 10711 func (m *MockEC2API) DescribeReservedInstancesOfferingsPages(arg0 *ec2.DescribeReservedInstancesOfferingsInput, arg1 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool) error { 10712 m.ctrl.T.Helper() 10713 ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsPages", arg0, arg1) 10714 ret0, _ := ret[0].(error) 10715 return ret0 10716 } 10717 10718 // DescribeReservedInstancesOfferingsPages indicates an expected call of DescribeReservedInstancesOfferingsPages 10719 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsPages(arg0, arg1 interface{}) *gomock.Call { 10720 mr.mock.ctrl.T.Helper() 10721 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPages), arg0, arg1) 10722 } 10723 10724 // DescribeReservedInstancesOfferingsPagesWithContext mocks base method 10725 func (m *MockEC2API) DescribeReservedInstancesOfferingsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeReservedInstancesOfferingsInput, arg2 func(*ec2.DescribeReservedInstancesOfferingsOutput, bool) bool, arg3 ...request.Option) error { 10726 m.ctrl.T.Helper() 10727 varargs := []interface{}{arg0, arg1, arg2} 10728 for _, a := range arg3 { 10729 varargs = append(varargs, a) 10730 } 10731 ret := m.ctrl.Call(m, "DescribeReservedInstancesOfferingsPagesWithContext", varargs...) 10732 ret0, _ := ret[0].(error) 10733 return ret0 10734 } 10735 10736 // DescribeReservedInstancesOfferingsPagesWithContext indicates an expected call of DescribeReservedInstancesOfferingsPagesWithContext 10737 func (mr *MockEC2APIMockRecorder) DescribeReservedInstancesOfferingsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10738 mr.mock.ctrl.T.Helper() 10739 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10740 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeReservedInstancesOfferingsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeReservedInstancesOfferingsPagesWithContext), varargs...) 10741 } 10742 10743 // DescribeRouteTables mocks base method 10744 func (m *MockEC2API) DescribeRouteTables(arg0 *ec2.DescribeRouteTablesInput) (*ec2.DescribeRouteTablesOutput, error) { 10745 m.ctrl.T.Helper() 10746 ret := m.ctrl.Call(m, "DescribeRouteTables", arg0) 10747 ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput) 10748 ret1, _ := ret[1].(error) 10749 return ret0, ret1 10750 } 10751 10752 // DescribeRouteTables indicates an expected call of DescribeRouteTables 10753 func (mr *MockEC2APIMockRecorder) DescribeRouteTables(arg0 interface{}) *gomock.Call { 10754 mr.mock.ctrl.T.Helper() 10755 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTables), arg0) 10756 } 10757 10758 // DescribeRouteTablesWithContext mocks base method 10759 func (m *MockEC2API) DescribeRouteTablesWithContext(arg0 aws.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeRouteTablesOutput, error) { 10760 m.ctrl.T.Helper() 10761 varargs := []interface{}{arg0, arg1} 10762 for _, a := range arg2 { 10763 varargs = append(varargs, a) 10764 } 10765 ret := m.ctrl.Call(m, "DescribeRouteTablesWithContext", varargs...) 10766 ret0, _ := ret[0].(*ec2.DescribeRouteTablesOutput) 10767 ret1, _ := ret[1].(error) 10768 return ret0, ret1 10769 } 10770 10771 // DescribeRouteTablesWithContext indicates an expected call of DescribeRouteTablesWithContext 10772 func (mr *MockEC2APIMockRecorder) DescribeRouteTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10773 mr.mock.ctrl.T.Helper() 10774 varargs := append([]interface{}{arg0, arg1}, arg2...) 10775 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesWithContext), varargs...) 10776 } 10777 10778 // DescribeRouteTablesRequest mocks base method 10779 func (m *MockEC2API) DescribeRouteTablesRequest(arg0 *ec2.DescribeRouteTablesInput) (*request.Request, *ec2.DescribeRouteTablesOutput) { 10780 m.ctrl.T.Helper() 10781 ret := m.ctrl.Call(m, "DescribeRouteTablesRequest", arg0) 10782 ret0, _ := ret[0].(*request.Request) 10783 ret1, _ := ret[1].(*ec2.DescribeRouteTablesOutput) 10784 return ret0, ret1 10785 } 10786 10787 // DescribeRouteTablesRequest indicates an expected call of DescribeRouteTablesRequest 10788 func (mr *MockEC2APIMockRecorder) DescribeRouteTablesRequest(arg0 interface{}) *gomock.Call { 10789 mr.mock.ctrl.T.Helper() 10790 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesRequest), arg0) 10791 } 10792 10793 // DescribeRouteTablesPages mocks base method 10794 func (m *MockEC2API) DescribeRouteTablesPages(arg0 *ec2.DescribeRouteTablesInput, arg1 func(*ec2.DescribeRouteTablesOutput, bool) bool) error { 10795 m.ctrl.T.Helper() 10796 ret := m.ctrl.Call(m, "DescribeRouteTablesPages", arg0, arg1) 10797 ret0, _ := ret[0].(error) 10798 return ret0 10799 } 10800 10801 // DescribeRouteTablesPages indicates an expected call of DescribeRouteTablesPages 10802 func (mr *MockEC2APIMockRecorder) DescribeRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { 10803 mr.mock.ctrl.T.Helper() 10804 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesPages), arg0, arg1) 10805 } 10806 10807 // DescribeRouteTablesPagesWithContext mocks base method 10808 func (m *MockEC2API) DescribeRouteTablesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeRouteTablesInput, arg2 func(*ec2.DescribeRouteTablesOutput, bool) bool, arg3 ...request.Option) error { 10809 m.ctrl.T.Helper() 10810 varargs := []interface{}{arg0, arg1, arg2} 10811 for _, a := range arg3 { 10812 varargs = append(varargs, a) 10813 } 10814 ret := m.ctrl.Call(m, "DescribeRouteTablesPagesWithContext", varargs...) 10815 ret0, _ := ret[0].(error) 10816 return ret0 10817 } 10818 10819 // DescribeRouteTablesPagesWithContext indicates an expected call of DescribeRouteTablesPagesWithContext 10820 func (mr *MockEC2APIMockRecorder) DescribeRouteTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10821 mr.mock.ctrl.T.Helper() 10822 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10823 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeRouteTablesPagesWithContext), varargs...) 10824 } 10825 10826 // DescribeScheduledInstanceAvailability mocks base method 10827 func (m *MockEC2API) DescribeScheduledInstanceAvailability(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) { 10828 m.ctrl.T.Helper() 10829 ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailability", arg0) 10830 ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput) 10831 ret1, _ := ret[1].(error) 10832 return ret0, ret1 10833 } 10834 10835 // DescribeScheduledInstanceAvailability indicates an expected call of DescribeScheduledInstanceAvailability 10836 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailability(arg0 interface{}) *gomock.Call { 10837 mr.mock.ctrl.T.Helper() 10838 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailability", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailability), arg0) 10839 } 10840 10841 // DescribeScheduledInstanceAvailabilityWithContext mocks base method 10842 func (m *MockEC2API) DescribeScheduledInstanceAvailabilityWithContext(arg0 aws.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstanceAvailabilityOutput, error) { 10843 m.ctrl.T.Helper() 10844 varargs := []interface{}{arg0, arg1} 10845 for _, a := range arg2 { 10846 varargs = append(varargs, a) 10847 } 10848 ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityWithContext", varargs...) 10849 ret0, _ := ret[0].(*ec2.DescribeScheduledInstanceAvailabilityOutput) 10850 ret1, _ := ret[1].(error) 10851 return ret0, ret1 10852 } 10853 10854 // DescribeScheduledInstanceAvailabilityWithContext indicates an expected call of DescribeScheduledInstanceAvailabilityWithContext 10855 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10856 mr.mock.ctrl.T.Helper() 10857 varargs := append([]interface{}{arg0, arg1}, arg2...) 10858 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityWithContext), varargs...) 10859 } 10860 10861 // DescribeScheduledInstanceAvailabilityRequest mocks base method 10862 func (m *MockEC2API) DescribeScheduledInstanceAvailabilityRequest(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput) (*request.Request, *ec2.DescribeScheduledInstanceAvailabilityOutput) { 10863 m.ctrl.T.Helper() 10864 ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityRequest", arg0) 10865 ret0, _ := ret[0].(*request.Request) 10866 ret1, _ := ret[1].(*ec2.DescribeScheduledInstanceAvailabilityOutput) 10867 return ret0, ret1 10868 } 10869 10870 // DescribeScheduledInstanceAvailabilityRequest indicates an expected call of DescribeScheduledInstanceAvailabilityRequest 10871 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityRequest(arg0 interface{}) *gomock.Call { 10872 mr.mock.ctrl.T.Helper() 10873 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityRequest), arg0) 10874 } 10875 10876 // DescribeScheduledInstanceAvailabilityPages mocks base method 10877 func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPages(arg0 *ec2.DescribeScheduledInstanceAvailabilityInput, arg1 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool) error { 10878 m.ctrl.T.Helper() 10879 ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityPages", arg0, arg1) 10880 ret0, _ := ret[0].(error) 10881 return ret0 10882 } 10883 10884 // DescribeScheduledInstanceAvailabilityPages indicates an expected call of DescribeScheduledInstanceAvailabilityPages 10885 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityPages(arg0, arg1 interface{}) *gomock.Call { 10886 mr.mock.ctrl.T.Helper() 10887 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPages), arg0, arg1) 10888 } 10889 10890 // DescribeScheduledInstanceAvailabilityPagesWithContext mocks base method 10891 func (m *MockEC2API) DescribeScheduledInstanceAvailabilityPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeScheduledInstanceAvailabilityInput, arg2 func(*ec2.DescribeScheduledInstanceAvailabilityOutput, bool) bool, arg3 ...request.Option) error { 10892 m.ctrl.T.Helper() 10893 varargs := []interface{}{arg0, arg1, arg2} 10894 for _, a := range arg3 { 10895 varargs = append(varargs, a) 10896 } 10897 ret := m.ctrl.Call(m, "DescribeScheduledInstanceAvailabilityPagesWithContext", varargs...) 10898 ret0, _ := ret[0].(error) 10899 return ret0 10900 } 10901 10902 // DescribeScheduledInstanceAvailabilityPagesWithContext indicates an expected call of DescribeScheduledInstanceAvailabilityPagesWithContext 10903 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstanceAvailabilityPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10904 mr.mock.ctrl.T.Helper() 10905 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10906 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstanceAvailabilityPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstanceAvailabilityPagesWithContext), varargs...) 10907 } 10908 10909 // DescribeScheduledInstances mocks base method 10910 func (m *MockEC2API) DescribeScheduledInstances(arg0 *ec2.DescribeScheduledInstancesInput) (*ec2.DescribeScheduledInstancesOutput, error) { 10911 m.ctrl.T.Helper() 10912 ret := m.ctrl.Call(m, "DescribeScheduledInstances", arg0) 10913 ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput) 10914 ret1, _ := ret[1].(error) 10915 return ret0, ret1 10916 } 10917 10918 // DescribeScheduledInstances indicates an expected call of DescribeScheduledInstances 10919 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstances(arg0 interface{}) *gomock.Call { 10920 mr.mock.ctrl.T.Helper() 10921 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstances), arg0) 10922 } 10923 10924 // DescribeScheduledInstancesWithContext mocks base method 10925 func (m *MockEC2API) DescribeScheduledInstancesWithContext(arg0 aws.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 ...request.Option) (*ec2.DescribeScheduledInstancesOutput, error) { 10926 m.ctrl.T.Helper() 10927 varargs := []interface{}{arg0, arg1} 10928 for _, a := range arg2 { 10929 varargs = append(varargs, a) 10930 } 10931 ret := m.ctrl.Call(m, "DescribeScheduledInstancesWithContext", varargs...) 10932 ret0, _ := ret[0].(*ec2.DescribeScheduledInstancesOutput) 10933 ret1, _ := ret[1].(error) 10934 return ret0, ret1 10935 } 10936 10937 // DescribeScheduledInstancesWithContext indicates an expected call of DescribeScheduledInstancesWithContext 10938 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 10939 mr.mock.ctrl.T.Helper() 10940 varargs := append([]interface{}{arg0, arg1}, arg2...) 10941 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesWithContext), varargs...) 10942 } 10943 10944 // DescribeScheduledInstancesRequest mocks base method 10945 func (m *MockEC2API) DescribeScheduledInstancesRequest(arg0 *ec2.DescribeScheduledInstancesInput) (*request.Request, *ec2.DescribeScheduledInstancesOutput) { 10946 m.ctrl.T.Helper() 10947 ret := m.ctrl.Call(m, "DescribeScheduledInstancesRequest", arg0) 10948 ret0, _ := ret[0].(*request.Request) 10949 ret1, _ := ret[1].(*ec2.DescribeScheduledInstancesOutput) 10950 return ret0, ret1 10951 } 10952 10953 // DescribeScheduledInstancesRequest indicates an expected call of DescribeScheduledInstancesRequest 10954 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesRequest(arg0 interface{}) *gomock.Call { 10955 mr.mock.ctrl.T.Helper() 10956 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesRequest), arg0) 10957 } 10958 10959 // DescribeScheduledInstancesPages mocks base method 10960 func (m *MockEC2API) DescribeScheduledInstancesPages(arg0 *ec2.DescribeScheduledInstancesInput, arg1 func(*ec2.DescribeScheduledInstancesOutput, bool) bool) error { 10961 m.ctrl.T.Helper() 10962 ret := m.ctrl.Call(m, "DescribeScheduledInstancesPages", arg0, arg1) 10963 ret0, _ := ret[0].(error) 10964 return ret0 10965 } 10966 10967 // DescribeScheduledInstancesPages indicates an expected call of DescribeScheduledInstancesPages 10968 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesPages(arg0, arg1 interface{}) *gomock.Call { 10969 mr.mock.ctrl.T.Helper() 10970 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesPages), arg0, arg1) 10971 } 10972 10973 // DescribeScheduledInstancesPagesWithContext mocks base method 10974 func (m *MockEC2API) DescribeScheduledInstancesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeScheduledInstancesInput, arg2 func(*ec2.DescribeScheduledInstancesOutput, bool) bool, arg3 ...request.Option) error { 10975 m.ctrl.T.Helper() 10976 varargs := []interface{}{arg0, arg1, arg2} 10977 for _, a := range arg3 { 10978 varargs = append(varargs, a) 10979 } 10980 ret := m.ctrl.Call(m, "DescribeScheduledInstancesPagesWithContext", varargs...) 10981 ret0, _ := ret[0].(error) 10982 return ret0 10983 } 10984 10985 // DescribeScheduledInstancesPagesWithContext indicates an expected call of DescribeScheduledInstancesPagesWithContext 10986 func (mr *MockEC2APIMockRecorder) DescribeScheduledInstancesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 10987 mr.mock.ctrl.T.Helper() 10988 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 10989 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeScheduledInstancesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeScheduledInstancesPagesWithContext), varargs...) 10990 } 10991 10992 // DescribeSecurityGroupReferences mocks base method 10993 func (m *MockEC2API) DescribeSecurityGroupReferences(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*ec2.DescribeSecurityGroupReferencesOutput, error) { 10994 m.ctrl.T.Helper() 10995 ret := m.ctrl.Call(m, "DescribeSecurityGroupReferences", arg0) 10996 ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput) 10997 ret1, _ := ret[1].(error) 10998 return ret0, ret1 10999 } 11000 11001 // DescribeSecurityGroupReferences indicates an expected call of DescribeSecurityGroupReferences 11002 func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferences(arg0 interface{}) *gomock.Call { 11003 mr.mock.ctrl.T.Helper() 11004 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferences", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferences), arg0) 11005 } 11006 11007 // DescribeSecurityGroupReferencesWithContext mocks base method 11008 func (m *MockEC2API) DescribeSecurityGroupReferencesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSecurityGroupReferencesInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupReferencesOutput, error) { 11009 m.ctrl.T.Helper() 11010 varargs := []interface{}{arg0, arg1} 11011 for _, a := range arg2 { 11012 varargs = append(varargs, a) 11013 } 11014 ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesWithContext", varargs...) 11015 ret0, _ := ret[0].(*ec2.DescribeSecurityGroupReferencesOutput) 11016 ret1, _ := ret[1].(error) 11017 return ret0, ret1 11018 } 11019 11020 // DescribeSecurityGroupReferencesWithContext indicates an expected call of DescribeSecurityGroupReferencesWithContext 11021 func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferencesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11022 mr.mock.ctrl.T.Helper() 11023 varargs := append([]interface{}{arg0, arg1}, arg2...) 11024 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferencesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferencesWithContext), varargs...) 11025 } 11026 11027 // DescribeSecurityGroupReferencesRequest mocks base method 11028 func (m *MockEC2API) DescribeSecurityGroupReferencesRequest(arg0 *ec2.DescribeSecurityGroupReferencesInput) (*request.Request, *ec2.DescribeSecurityGroupReferencesOutput) { 11029 m.ctrl.T.Helper() 11030 ret := m.ctrl.Call(m, "DescribeSecurityGroupReferencesRequest", arg0) 11031 ret0, _ := ret[0].(*request.Request) 11032 ret1, _ := ret[1].(*ec2.DescribeSecurityGroupReferencesOutput) 11033 return ret0, ret1 11034 } 11035 11036 // DescribeSecurityGroupReferencesRequest indicates an expected call of DescribeSecurityGroupReferencesRequest 11037 func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupReferencesRequest(arg0 interface{}) *gomock.Call { 11038 mr.mock.ctrl.T.Helper() 11039 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupReferencesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupReferencesRequest), arg0) 11040 } 11041 11042 // DescribeSecurityGroups mocks base method 11043 func (m *MockEC2API) DescribeSecurityGroups(arg0 *ec2.DescribeSecurityGroupsInput) (*ec2.DescribeSecurityGroupsOutput, error) { 11044 m.ctrl.T.Helper() 11045 ret := m.ctrl.Call(m, "DescribeSecurityGroups", arg0) 11046 ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput) 11047 ret1, _ := ret[1].(error) 11048 return ret0, ret1 11049 } 11050 11051 // DescribeSecurityGroups indicates an expected call of DescribeSecurityGroups 11052 func (mr *MockEC2APIMockRecorder) DescribeSecurityGroups(arg0 interface{}) *gomock.Call { 11053 mr.mock.ctrl.T.Helper() 11054 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroups), arg0) 11055 } 11056 11057 // DescribeSecurityGroupsWithContext mocks base method 11058 func (m *MockEC2API) DescribeSecurityGroupsWithContext(arg0 aws.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeSecurityGroupsOutput, error) { 11059 m.ctrl.T.Helper() 11060 varargs := []interface{}{arg0, arg1} 11061 for _, a := range arg2 { 11062 varargs = append(varargs, a) 11063 } 11064 ret := m.ctrl.Call(m, "DescribeSecurityGroupsWithContext", varargs...) 11065 ret0, _ := ret[0].(*ec2.DescribeSecurityGroupsOutput) 11066 ret1, _ := ret[1].(error) 11067 return ret0, ret1 11068 } 11069 11070 // DescribeSecurityGroupsWithContext indicates an expected call of DescribeSecurityGroupsWithContext 11071 func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11072 mr.mock.ctrl.T.Helper() 11073 varargs := append([]interface{}{arg0, arg1}, arg2...) 11074 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsWithContext), varargs...) 11075 } 11076 11077 // DescribeSecurityGroupsRequest mocks base method 11078 func (m *MockEC2API) DescribeSecurityGroupsRequest(arg0 *ec2.DescribeSecurityGroupsInput) (*request.Request, *ec2.DescribeSecurityGroupsOutput) { 11079 m.ctrl.T.Helper() 11080 ret := m.ctrl.Call(m, "DescribeSecurityGroupsRequest", arg0) 11081 ret0, _ := ret[0].(*request.Request) 11082 ret1, _ := ret[1].(*ec2.DescribeSecurityGroupsOutput) 11083 return ret0, ret1 11084 } 11085 11086 // DescribeSecurityGroupsRequest indicates an expected call of DescribeSecurityGroupsRequest 11087 func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsRequest(arg0 interface{}) *gomock.Call { 11088 mr.mock.ctrl.T.Helper() 11089 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsRequest), arg0) 11090 } 11091 11092 // DescribeSecurityGroupsPages mocks base method 11093 func (m *MockEC2API) DescribeSecurityGroupsPages(arg0 *ec2.DescribeSecurityGroupsInput, arg1 func(*ec2.DescribeSecurityGroupsOutput, bool) bool) error { 11094 m.ctrl.T.Helper() 11095 ret := m.ctrl.Call(m, "DescribeSecurityGroupsPages", arg0, arg1) 11096 ret0, _ := ret[0].(error) 11097 return ret0 11098 } 11099 11100 // DescribeSecurityGroupsPages indicates an expected call of DescribeSecurityGroupsPages 11101 func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { 11102 mr.mock.ctrl.T.Helper() 11103 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsPages), arg0, arg1) 11104 } 11105 11106 // DescribeSecurityGroupsPagesWithContext mocks base method 11107 func (m *MockEC2API) DescribeSecurityGroupsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSecurityGroupsInput, arg2 func(*ec2.DescribeSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error { 11108 m.ctrl.T.Helper() 11109 varargs := []interface{}{arg0, arg1, arg2} 11110 for _, a := range arg3 { 11111 varargs = append(varargs, a) 11112 } 11113 ret := m.ctrl.Call(m, "DescribeSecurityGroupsPagesWithContext", varargs...) 11114 ret0, _ := ret[0].(error) 11115 return ret0 11116 } 11117 11118 // DescribeSecurityGroupsPagesWithContext indicates an expected call of DescribeSecurityGroupsPagesWithContext 11119 func (mr *MockEC2APIMockRecorder) DescribeSecurityGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11120 mr.mock.ctrl.T.Helper() 11121 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11122 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSecurityGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSecurityGroupsPagesWithContext), varargs...) 11123 } 11124 11125 // DescribeSnapshotAttribute mocks base method 11126 func (m *MockEC2API) DescribeSnapshotAttribute(arg0 *ec2.DescribeSnapshotAttributeInput) (*ec2.DescribeSnapshotAttributeOutput, error) { 11127 m.ctrl.T.Helper() 11128 ret := m.ctrl.Call(m, "DescribeSnapshotAttribute", arg0) 11129 ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput) 11130 ret1, _ := ret[1].(error) 11131 return ret0, ret1 11132 } 11133 11134 // DescribeSnapshotAttribute indicates an expected call of DescribeSnapshotAttribute 11135 func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttribute(arg0 interface{}) *gomock.Call { 11136 mr.mock.ctrl.T.Helper() 11137 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttribute), arg0) 11138 } 11139 11140 // DescribeSnapshotAttributeWithContext mocks base method 11141 func (m *MockEC2API) DescribeSnapshotAttributeWithContext(arg0 aws.Context, arg1 *ec2.DescribeSnapshotAttributeInput, arg2 ...request.Option) (*ec2.DescribeSnapshotAttributeOutput, error) { 11142 m.ctrl.T.Helper() 11143 varargs := []interface{}{arg0, arg1} 11144 for _, a := range arg2 { 11145 varargs = append(varargs, a) 11146 } 11147 ret := m.ctrl.Call(m, "DescribeSnapshotAttributeWithContext", varargs...) 11148 ret0, _ := ret[0].(*ec2.DescribeSnapshotAttributeOutput) 11149 ret1, _ := ret[1].(error) 11150 return ret0, ret1 11151 } 11152 11153 // DescribeSnapshotAttributeWithContext indicates an expected call of DescribeSnapshotAttributeWithContext 11154 func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11155 mr.mock.ctrl.T.Helper() 11156 varargs := append([]interface{}{arg0, arg1}, arg2...) 11157 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttributeWithContext), varargs...) 11158 } 11159 11160 // DescribeSnapshotAttributeRequest mocks base method 11161 func (m *MockEC2API) DescribeSnapshotAttributeRequest(arg0 *ec2.DescribeSnapshotAttributeInput) (*request.Request, *ec2.DescribeSnapshotAttributeOutput) { 11162 m.ctrl.T.Helper() 11163 ret := m.ctrl.Call(m, "DescribeSnapshotAttributeRequest", arg0) 11164 ret0, _ := ret[0].(*request.Request) 11165 ret1, _ := ret[1].(*ec2.DescribeSnapshotAttributeOutput) 11166 return ret0, ret1 11167 } 11168 11169 // DescribeSnapshotAttributeRequest indicates an expected call of DescribeSnapshotAttributeRequest 11170 func (mr *MockEC2APIMockRecorder) DescribeSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { 11171 mr.mock.ctrl.T.Helper() 11172 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotAttributeRequest), arg0) 11173 } 11174 11175 // DescribeSnapshots mocks base method 11176 func (m *MockEC2API) DescribeSnapshots(arg0 *ec2.DescribeSnapshotsInput) (*ec2.DescribeSnapshotsOutput, error) { 11177 m.ctrl.T.Helper() 11178 ret := m.ctrl.Call(m, "DescribeSnapshots", arg0) 11179 ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput) 11180 ret1, _ := ret[1].(error) 11181 return ret0, ret1 11182 } 11183 11184 // DescribeSnapshots indicates an expected call of DescribeSnapshots 11185 func (mr *MockEC2APIMockRecorder) DescribeSnapshots(arg0 interface{}) *gomock.Call { 11186 mr.mock.ctrl.T.Helper() 11187 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshots", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshots), arg0) 11188 } 11189 11190 // DescribeSnapshotsWithContext mocks base method 11191 func (m *MockEC2API) DescribeSnapshotsWithContext(arg0 aws.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.Option) (*ec2.DescribeSnapshotsOutput, error) { 11192 m.ctrl.T.Helper() 11193 varargs := []interface{}{arg0, arg1} 11194 for _, a := range arg2 { 11195 varargs = append(varargs, a) 11196 } 11197 ret := m.ctrl.Call(m, "DescribeSnapshotsWithContext", varargs...) 11198 ret0, _ := ret[0].(*ec2.DescribeSnapshotsOutput) 11199 ret1, _ := ret[1].(error) 11200 return ret0, ret1 11201 } 11202 11203 // DescribeSnapshotsWithContext indicates an expected call of DescribeSnapshotsWithContext 11204 func (mr *MockEC2APIMockRecorder) DescribeSnapshotsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11205 mr.mock.ctrl.T.Helper() 11206 varargs := append([]interface{}{arg0, arg1}, arg2...) 11207 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsWithContext), varargs...) 11208 } 11209 11210 // DescribeSnapshotsRequest mocks base method 11211 func (m *MockEC2API) DescribeSnapshotsRequest(arg0 *ec2.DescribeSnapshotsInput) (*request.Request, *ec2.DescribeSnapshotsOutput) { 11212 m.ctrl.T.Helper() 11213 ret := m.ctrl.Call(m, "DescribeSnapshotsRequest", arg0) 11214 ret0, _ := ret[0].(*request.Request) 11215 ret1, _ := ret[1].(*ec2.DescribeSnapshotsOutput) 11216 return ret0, ret1 11217 } 11218 11219 // DescribeSnapshotsRequest indicates an expected call of DescribeSnapshotsRequest 11220 func (mr *MockEC2APIMockRecorder) DescribeSnapshotsRequest(arg0 interface{}) *gomock.Call { 11221 mr.mock.ctrl.T.Helper() 11222 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsRequest), arg0) 11223 } 11224 11225 // DescribeSnapshotsPages mocks base method 11226 func (m *MockEC2API) DescribeSnapshotsPages(arg0 *ec2.DescribeSnapshotsInput, arg1 func(*ec2.DescribeSnapshotsOutput, bool) bool) error { 11227 m.ctrl.T.Helper() 11228 ret := m.ctrl.Call(m, "DescribeSnapshotsPages", arg0, arg1) 11229 ret0, _ := ret[0].(error) 11230 return ret0 11231 } 11232 11233 // DescribeSnapshotsPages indicates an expected call of DescribeSnapshotsPages 11234 func (mr *MockEC2APIMockRecorder) DescribeSnapshotsPages(arg0, arg1 interface{}) *gomock.Call { 11235 mr.mock.ctrl.T.Helper() 11236 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsPages), arg0, arg1) 11237 } 11238 11239 // DescribeSnapshotsPagesWithContext mocks base method 11240 func (m *MockEC2API) DescribeSnapshotsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 func(*ec2.DescribeSnapshotsOutput, bool) bool, arg3 ...request.Option) error { 11241 m.ctrl.T.Helper() 11242 varargs := []interface{}{arg0, arg1, arg2} 11243 for _, a := range arg3 { 11244 varargs = append(varargs, a) 11245 } 11246 ret := m.ctrl.Call(m, "DescribeSnapshotsPagesWithContext", varargs...) 11247 ret0, _ := ret[0].(error) 11248 return ret0 11249 } 11250 11251 // DescribeSnapshotsPagesWithContext indicates an expected call of DescribeSnapshotsPagesWithContext 11252 func (mr *MockEC2APIMockRecorder) DescribeSnapshotsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11253 mr.mock.ctrl.T.Helper() 11254 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11255 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSnapshotsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSnapshotsPagesWithContext), varargs...) 11256 } 11257 11258 // DescribeSpotDatafeedSubscription mocks base method 11259 func (m *MockEC2API) DescribeSpotDatafeedSubscription(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) { 11260 m.ctrl.T.Helper() 11261 ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscription", arg0) 11262 ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput) 11263 ret1, _ := ret[1].(error) 11264 return ret0, ret1 11265 } 11266 11267 // DescribeSpotDatafeedSubscription indicates an expected call of DescribeSpotDatafeedSubscription 11268 func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscription(arg0 interface{}) *gomock.Call { 11269 mr.mock.ctrl.T.Helper() 11270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscription", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscription), arg0) 11271 } 11272 11273 // DescribeSpotDatafeedSubscriptionWithContext mocks base method 11274 func (m *MockEC2API) DescribeSpotDatafeedSubscriptionWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotDatafeedSubscriptionInput, arg2 ...request.Option) (*ec2.DescribeSpotDatafeedSubscriptionOutput, error) { 11275 m.ctrl.T.Helper() 11276 varargs := []interface{}{arg0, arg1} 11277 for _, a := range arg2 { 11278 varargs = append(varargs, a) 11279 } 11280 ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionWithContext", varargs...) 11281 ret0, _ := ret[0].(*ec2.DescribeSpotDatafeedSubscriptionOutput) 11282 ret1, _ := ret[1].(error) 11283 return ret0, ret1 11284 } 11285 11286 // DescribeSpotDatafeedSubscriptionWithContext indicates an expected call of DescribeSpotDatafeedSubscriptionWithContext 11287 func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscriptionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11288 mr.mock.ctrl.T.Helper() 11289 varargs := append([]interface{}{arg0, arg1}, arg2...) 11290 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscriptionWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionWithContext), varargs...) 11291 } 11292 11293 // DescribeSpotDatafeedSubscriptionRequest mocks base method 11294 func (m *MockEC2API) DescribeSpotDatafeedSubscriptionRequest(arg0 *ec2.DescribeSpotDatafeedSubscriptionInput) (*request.Request, *ec2.DescribeSpotDatafeedSubscriptionOutput) { 11295 m.ctrl.T.Helper() 11296 ret := m.ctrl.Call(m, "DescribeSpotDatafeedSubscriptionRequest", arg0) 11297 ret0, _ := ret[0].(*request.Request) 11298 ret1, _ := ret[1].(*ec2.DescribeSpotDatafeedSubscriptionOutput) 11299 return ret0, ret1 11300 } 11301 11302 // DescribeSpotDatafeedSubscriptionRequest indicates an expected call of DescribeSpotDatafeedSubscriptionRequest 11303 func (mr *MockEC2APIMockRecorder) DescribeSpotDatafeedSubscriptionRequest(arg0 interface{}) *gomock.Call { 11304 mr.mock.ctrl.T.Helper() 11305 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotDatafeedSubscriptionRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotDatafeedSubscriptionRequest), arg0) 11306 } 11307 11308 // DescribeSpotFleetInstances mocks base method 11309 func (m *MockEC2API) DescribeSpotFleetInstances(arg0 *ec2.DescribeSpotFleetInstancesInput) (*ec2.DescribeSpotFleetInstancesOutput, error) { 11310 m.ctrl.T.Helper() 11311 ret := m.ctrl.Call(m, "DescribeSpotFleetInstances", arg0) 11312 ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput) 11313 ret1, _ := ret[1].(error) 11314 return ret0, ret1 11315 } 11316 11317 // DescribeSpotFleetInstances indicates an expected call of DescribeSpotFleetInstances 11318 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstances(arg0 interface{}) *gomock.Call { 11319 mr.mock.ctrl.T.Helper() 11320 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstances", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstances), arg0) 11321 } 11322 11323 // DescribeSpotFleetInstancesWithContext mocks base method 11324 func (m *MockEC2API) DescribeSpotFleetInstancesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotFleetInstancesInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetInstancesOutput, error) { 11325 m.ctrl.T.Helper() 11326 varargs := []interface{}{arg0, arg1} 11327 for _, a := range arg2 { 11328 varargs = append(varargs, a) 11329 } 11330 ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesWithContext", varargs...) 11331 ret0, _ := ret[0].(*ec2.DescribeSpotFleetInstancesOutput) 11332 ret1, _ := ret[1].(error) 11333 return ret0, ret1 11334 } 11335 11336 // DescribeSpotFleetInstancesWithContext indicates an expected call of DescribeSpotFleetInstancesWithContext 11337 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11338 mr.mock.ctrl.T.Helper() 11339 varargs := append([]interface{}{arg0, arg1}, arg2...) 11340 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstancesWithContext), varargs...) 11341 } 11342 11343 // DescribeSpotFleetInstancesRequest mocks base method 11344 func (m *MockEC2API) DescribeSpotFleetInstancesRequest(arg0 *ec2.DescribeSpotFleetInstancesInput) (*request.Request, *ec2.DescribeSpotFleetInstancesOutput) { 11345 m.ctrl.T.Helper() 11346 ret := m.ctrl.Call(m, "DescribeSpotFleetInstancesRequest", arg0) 11347 ret0, _ := ret[0].(*request.Request) 11348 ret1, _ := ret[1].(*ec2.DescribeSpotFleetInstancesOutput) 11349 return ret0, ret1 11350 } 11351 11352 // DescribeSpotFleetInstancesRequest indicates an expected call of DescribeSpotFleetInstancesRequest 11353 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetInstancesRequest(arg0 interface{}) *gomock.Call { 11354 mr.mock.ctrl.T.Helper() 11355 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetInstancesRequest), arg0) 11356 } 11357 11358 // DescribeSpotFleetRequestHistory mocks base method 11359 func (m *MockEC2API) DescribeSpotFleetRequestHistory(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) { 11360 m.ctrl.T.Helper() 11361 ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistory", arg0) 11362 ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput) 11363 ret1, _ := ret[1].(error) 11364 return ret0, ret1 11365 } 11366 11367 // DescribeSpotFleetRequestHistory indicates an expected call of DescribeSpotFleetRequestHistory 11368 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistory(arg0 interface{}) *gomock.Call { 11369 mr.mock.ctrl.T.Helper() 11370 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistory), arg0) 11371 } 11372 11373 // DescribeSpotFleetRequestHistoryWithContext mocks base method 11374 func (m *MockEC2API) DescribeSpotFleetRequestHistoryWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotFleetRequestHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestHistoryOutput, error) { 11375 m.ctrl.T.Helper() 11376 varargs := []interface{}{arg0, arg1} 11377 for _, a := range arg2 { 11378 varargs = append(varargs, a) 11379 } 11380 ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryWithContext", varargs...) 11381 ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestHistoryOutput) 11382 ret1, _ := ret[1].(error) 11383 return ret0, ret1 11384 } 11385 11386 // DescribeSpotFleetRequestHistoryWithContext indicates an expected call of DescribeSpotFleetRequestHistoryWithContext 11387 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11388 mr.mock.ctrl.T.Helper() 11389 varargs := append([]interface{}{arg0, arg1}, arg2...) 11390 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryWithContext), varargs...) 11391 } 11392 11393 // DescribeSpotFleetRequestHistoryRequest mocks base method 11394 func (m *MockEC2API) DescribeSpotFleetRequestHistoryRequest(arg0 *ec2.DescribeSpotFleetRequestHistoryInput) (*request.Request, *ec2.DescribeSpotFleetRequestHistoryOutput) { 11395 m.ctrl.T.Helper() 11396 ret := m.ctrl.Call(m, "DescribeSpotFleetRequestHistoryRequest", arg0) 11397 ret0, _ := ret[0].(*request.Request) 11398 ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestHistoryOutput) 11399 return ret0, ret1 11400 } 11401 11402 // DescribeSpotFleetRequestHistoryRequest indicates an expected call of DescribeSpotFleetRequestHistoryRequest 11403 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestHistoryRequest(arg0 interface{}) *gomock.Call { 11404 mr.mock.ctrl.T.Helper() 11405 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestHistoryRequest), arg0) 11406 } 11407 11408 // DescribeSpotFleetRequests mocks base method 11409 func (m *MockEC2API) DescribeSpotFleetRequests(arg0 *ec2.DescribeSpotFleetRequestsInput) (*ec2.DescribeSpotFleetRequestsOutput, error) { 11410 m.ctrl.T.Helper() 11411 ret := m.ctrl.Call(m, "DescribeSpotFleetRequests", arg0) 11412 ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput) 11413 ret1, _ := ret[1].(error) 11414 return ret0, ret1 11415 } 11416 11417 // DescribeSpotFleetRequests indicates an expected call of DescribeSpotFleetRequests 11418 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequests(arg0 interface{}) *gomock.Call { 11419 mr.mock.ctrl.T.Helper() 11420 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequests), arg0) 11421 } 11422 11423 // DescribeSpotFleetRequestsWithContext mocks base method 11424 func (m *MockEC2API) DescribeSpotFleetRequestsWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotFleetRequestsOutput, error) { 11425 m.ctrl.T.Helper() 11426 varargs := []interface{}{arg0, arg1} 11427 for _, a := range arg2 { 11428 varargs = append(varargs, a) 11429 } 11430 ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsWithContext", varargs...) 11431 ret0, _ := ret[0].(*ec2.DescribeSpotFleetRequestsOutput) 11432 ret1, _ := ret[1].(error) 11433 return ret0, ret1 11434 } 11435 11436 // DescribeSpotFleetRequestsWithContext indicates an expected call of DescribeSpotFleetRequestsWithContext 11437 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11438 mr.mock.ctrl.T.Helper() 11439 varargs := append([]interface{}{arg0, arg1}, arg2...) 11440 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsWithContext), varargs...) 11441 } 11442 11443 // DescribeSpotFleetRequestsRequest mocks base method 11444 func (m *MockEC2API) DescribeSpotFleetRequestsRequest(arg0 *ec2.DescribeSpotFleetRequestsInput) (*request.Request, *ec2.DescribeSpotFleetRequestsOutput) { 11445 m.ctrl.T.Helper() 11446 ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsRequest", arg0) 11447 ret0, _ := ret[0].(*request.Request) 11448 ret1, _ := ret[1].(*ec2.DescribeSpotFleetRequestsOutput) 11449 return ret0, ret1 11450 } 11451 11452 // DescribeSpotFleetRequestsRequest indicates an expected call of DescribeSpotFleetRequestsRequest 11453 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsRequest(arg0 interface{}) *gomock.Call { 11454 mr.mock.ctrl.T.Helper() 11455 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsRequest), arg0) 11456 } 11457 11458 // DescribeSpotFleetRequestsPages mocks base method 11459 func (m *MockEC2API) DescribeSpotFleetRequestsPages(arg0 *ec2.DescribeSpotFleetRequestsInput, arg1 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool) error { 11460 m.ctrl.T.Helper() 11461 ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsPages", arg0, arg1) 11462 ret0, _ := ret[0].(error) 11463 return ret0 11464 } 11465 11466 // DescribeSpotFleetRequestsPages indicates an expected call of DescribeSpotFleetRequestsPages 11467 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsPages(arg0, arg1 interface{}) *gomock.Call { 11468 mr.mock.ctrl.T.Helper() 11469 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsPages), arg0, arg1) 11470 } 11471 11472 // DescribeSpotFleetRequestsPagesWithContext mocks base method 11473 func (m *MockEC2API) DescribeSpotFleetRequestsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotFleetRequestsInput, arg2 func(*ec2.DescribeSpotFleetRequestsOutput, bool) bool, arg3 ...request.Option) error { 11474 m.ctrl.T.Helper() 11475 varargs := []interface{}{arg0, arg1, arg2} 11476 for _, a := range arg3 { 11477 varargs = append(varargs, a) 11478 } 11479 ret := m.ctrl.Call(m, "DescribeSpotFleetRequestsPagesWithContext", varargs...) 11480 ret0, _ := ret[0].(error) 11481 return ret0 11482 } 11483 11484 // DescribeSpotFleetRequestsPagesWithContext indicates an expected call of DescribeSpotFleetRequestsPagesWithContext 11485 func (mr *MockEC2APIMockRecorder) DescribeSpotFleetRequestsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11486 mr.mock.ctrl.T.Helper() 11487 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11488 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotFleetRequestsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotFleetRequestsPagesWithContext), varargs...) 11489 } 11490 11491 // DescribeSpotInstanceRequests mocks base method 11492 func (m *MockEC2API) DescribeSpotInstanceRequests(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*ec2.DescribeSpotInstanceRequestsOutput, error) { 11493 m.ctrl.T.Helper() 11494 ret := m.ctrl.Call(m, "DescribeSpotInstanceRequests", arg0) 11495 ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput) 11496 ret1, _ := ret[1].(error) 11497 return ret0, ret1 11498 } 11499 11500 // DescribeSpotInstanceRequests indicates an expected call of DescribeSpotInstanceRequests 11501 func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequests(arg0 interface{}) *gomock.Call { 11502 mr.mock.ctrl.T.Helper() 11503 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequests", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequests), arg0) 11504 } 11505 11506 // DescribeSpotInstanceRequestsWithContext mocks base method 11507 func (m *MockEC2API) DescribeSpotInstanceRequestsWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 ...request.Option) (*ec2.DescribeSpotInstanceRequestsOutput, error) { 11508 m.ctrl.T.Helper() 11509 varargs := []interface{}{arg0, arg1} 11510 for _, a := range arg2 { 11511 varargs = append(varargs, a) 11512 } 11513 ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsWithContext", varargs...) 11514 ret0, _ := ret[0].(*ec2.DescribeSpotInstanceRequestsOutput) 11515 ret1, _ := ret[1].(error) 11516 return ret0, ret1 11517 } 11518 11519 // DescribeSpotInstanceRequestsWithContext indicates an expected call of DescribeSpotInstanceRequestsWithContext 11520 func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11521 mr.mock.ctrl.T.Helper() 11522 varargs := append([]interface{}{arg0, arg1}, arg2...) 11523 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsWithContext), varargs...) 11524 } 11525 11526 // DescribeSpotInstanceRequestsRequest mocks base method 11527 func (m *MockEC2API) DescribeSpotInstanceRequestsRequest(arg0 *ec2.DescribeSpotInstanceRequestsInput) (*request.Request, *ec2.DescribeSpotInstanceRequestsOutput) { 11528 m.ctrl.T.Helper() 11529 ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsRequest", arg0) 11530 ret0, _ := ret[0].(*request.Request) 11531 ret1, _ := ret[1].(*ec2.DescribeSpotInstanceRequestsOutput) 11532 return ret0, ret1 11533 } 11534 11535 // DescribeSpotInstanceRequestsRequest indicates an expected call of DescribeSpotInstanceRequestsRequest 11536 func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsRequest(arg0 interface{}) *gomock.Call { 11537 mr.mock.ctrl.T.Helper() 11538 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsRequest), arg0) 11539 } 11540 11541 // DescribeSpotInstanceRequestsPages mocks base method 11542 func (m *MockEC2API) DescribeSpotInstanceRequestsPages(arg0 *ec2.DescribeSpotInstanceRequestsInput, arg1 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool) error { 11543 m.ctrl.T.Helper() 11544 ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsPages", arg0, arg1) 11545 ret0, _ := ret[0].(error) 11546 return ret0 11547 } 11548 11549 // DescribeSpotInstanceRequestsPages indicates an expected call of DescribeSpotInstanceRequestsPages 11550 func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsPages(arg0, arg1 interface{}) *gomock.Call { 11551 mr.mock.ctrl.T.Helper() 11552 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsPages), arg0, arg1) 11553 } 11554 11555 // DescribeSpotInstanceRequestsPagesWithContext mocks base method 11556 func (m *MockEC2API) DescribeSpotInstanceRequestsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 func(*ec2.DescribeSpotInstanceRequestsOutput, bool) bool, arg3 ...request.Option) error { 11557 m.ctrl.T.Helper() 11558 varargs := []interface{}{arg0, arg1, arg2} 11559 for _, a := range arg3 { 11560 varargs = append(varargs, a) 11561 } 11562 ret := m.ctrl.Call(m, "DescribeSpotInstanceRequestsPagesWithContext", varargs...) 11563 ret0, _ := ret[0].(error) 11564 return ret0 11565 } 11566 11567 // DescribeSpotInstanceRequestsPagesWithContext indicates an expected call of DescribeSpotInstanceRequestsPagesWithContext 11568 func (mr *MockEC2APIMockRecorder) DescribeSpotInstanceRequestsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11569 mr.mock.ctrl.T.Helper() 11570 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11571 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotInstanceRequestsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotInstanceRequestsPagesWithContext), varargs...) 11572 } 11573 11574 // DescribeSpotPriceHistory mocks base method 11575 func (m *MockEC2API) DescribeSpotPriceHistory(arg0 *ec2.DescribeSpotPriceHistoryInput) (*ec2.DescribeSpotPriceHistoryOutput, error) { 11576 m.ctrl.T.Helper() 11577 ret := m.ctrl.Call(m, "DescribeSpotPriceHistory", arg0) 11578 ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput) 11579 ret1, _ := ret[1].(error) 11580 return ret0, ret1 11581 } 11582 11583 // DescribeSpotPriceHistory indicates an expected call of DescribeSpotPriceHistory 11584 func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistory(arg0 interface{}) *gomock.Call { 11585 mr.mock.ctrl.T.Helper() 11586 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistory", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistory), arg0) 11587 } 11588 11589 // DescribeSpotPriceHistoryWithContext mocks base method 11590 func (m *MockEC2API) DescribeSpotPriceHistoryWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 ...request.Option) (*ec2.DescribeSpotPriceHistoryOutput, error) { 11591 m.ctrl.T.Helper() 11592 varargs := []interface{}{arg0, arg1} 11593 for _, a := range arg2 { 11594 varargs = append(varargs, a) 11595 } 11596 ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryWithContext", varargs...) 11597 ret0, _ := ret[0].(*ec2.DescribeSpotPriceHistoryOutput) 11598 ret1, _ := ret[1].(error) 11599 return ret0, ret1 11600 } 11601 11602 // DescribeSpotPriceHistoryWithContext indicates an expected call of DescribeSpotPriceHistoryWithContext 11603 func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11604 mr.mock.ctrl.T.Helper() 11605 varargs := append([]interface{}{arg0, arg1}, arg2...) 11606 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryWithContext), varargs...) 11607 } 11608 11609 // DescribeSpotPriceHistoryRequest mocks base method 11610 func (m *MockEC2API) DescribeSpotPriceHistoryRequest(arg0 *ec2.DescribeSpotPriceHistoryInput) (*request.Request, *ec2.DescribeSpotPriceHistoryOutput) { 11611 m.ctrl.T.Helper() 11612 ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryRequest", arg0) 11613 ret0, _ := ret[0].(*request.Request) 11614 ret1, _ := ret[1].(*ec2.DescribeSpotPriceHistoryOutput) 11615 return ret0, ret1 11616 } 11617 11618 // DescribeSpotPriceHistoryRequest indicates an expected call of DescribeSpotPriceHistoryRequest 11619 func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryRequest(arg0 interface{}) *gomock.Call { 11620 mr.mock.ctrl.T.Helper() 11621 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryRequest), arg0) 11622 } 11623 11624 // DescribeSpotPriceHistoryPages mocks base method 11625 func (m *MockEC2API) DescribeSpotPriceHistoryPages(arg0 *ec2.DescribeSpotPriceHistoryInput, arg1 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool) error { 11626 m.ctrl.T.Helper() 11627 ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryPages", arg0, arg1) 11628 ret0, _ := ret[0].(error) 11629 return ret0 11630 } 11631 11632 // DescribeSpotPriceHistoryPages indicates an expected call of DescribeSpotPriceHistoryPages 11633 func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryPages(arg0, arg1 interface{}) *gomock.Call { 11634 mr.mock.ctrl.T.Helper() 11635 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryPages), arg0, arg1) 11636 } 11637 11638 // DescribeSpotPriceHistoryPagesWithContext mocks base method 11639 func (m *MockEC2API) DescribeSpotPriceHistoryPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotPriceHistoryInput, arg2 func(*ec2.DescribeSpotPriceHistoryOutput, bool) bool, arg3 ...request.Option) error { 11640 m.ctrl.T.Helper() 11641 varargs := []interface{}{arg0, arg1, arg2} 11642 for _, a := range arg3 { 11643 varargs = append(varargs, a) 11644 } 11645 ret := m.ctrl.Call(m, "DescribeSpotPriceHistoryPagesWithContext", varargs...) 11646 ret0, _ := ret[0].(error) 11647 return ret0 11648 } 11649 11650 // DescribeSpotPriceHistoryPagesWithContext indicates an expected call of DescribeSpotPriceHistoryPagesWithContext 11651 func (mr *MockEC2APIMockRecorder) DescribeSpotPriceHistoryPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11652 mr.mock.ctrl.T.Helper() 11653 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11654 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSpotPriceHistoryPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSpotPriceHistoryPagesWithContext), varargs...) 11655 } 11656 11657 // DescribeStaleSecurityGroups mocks base method 11658 func (m *MockEC2API) DescribeStaleSecurityGroups(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*ec2.DescribeStaleSecurityGroupsOutput, error) { 11659 m.ctrl.T.Helper() 11660 ret := m.ctrl.Call(m, "DescribeStaleSecurityGroups", arg0) 11661 ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput) 11662 ret1, _ := ret[1].(error) 11663 return ret0, ret1 11664 } 11665 11666 // DescribeStaleSecurityGroups indicates an expected call of DescribeStaleSecurityGroups 11667 func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroups(arg0 interface{}) *gomock.Call { 11668 mr.mock.ctrl.T.Helper() 11669 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroups", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroups), arg0) 11670 } 11671 11672 // DescribeStaleSecurityGroupsWithContext mocks base method 11673 func (m *MockEC2API) DescribeStaleSecurityGroupsWithContext(arg0 aws.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 ...request.Option) (*ec2.DescribeStaleSecurityGroupsOutput, error) { 11674 m.ctrl.T.Helper() 11675 varargs := []interface{}{arg0, arg1} 11676 for _, a := range arg2 { 11677 varargs = append(varargs, a) 11678 } 11679 ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsWithContext", varargs...) 11680 ret0, _ := ret[0].(*ec2.DescribeStaleSecurityGroupsOutput) 11681 ret1, _ := ret[1].(error) 11682 return ret0, ret1 11683 } 11684 11685 // DescribeStaleSecurityGroupsWithContext indicates an expected call of DescribeStaleSecurityGroupsWithContext 11686 func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11687 mr.mock.ctrl.T.Helper() 11688 varargs := append([]interface{}{arg0, arg1}, arg2...) 11689 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsWithContext), varargs...) 11690 } 11691 11692 // DescribeStaleSecurityGroupsRequest mocks base method 11693 func (m *MockEC2API) DescribeStaleSecurityGroupsRequest(arg0 *ec2.DescribeStaleSecurityGroupsInput) (*request.Request, *ec2.DescribeStaleSecurityGroupsOutput) { 11694 m.ctrl.T.Helper() 11695 ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsRequest", arg0) 11696 ret0, _ := ret[0].(*request.Request) 11697 ret1, _ := ret[1].(*ec2.DescribeStaleSecurityGroupsOutput) 11698 return ret0, ret1 11699 } 11700 11701 // DescribeStaleSecurityGroupsRequest indicates an expected call of DescribeStaleSecurityGroupsRequest 11702 func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsRequest(arg0 interface{}) *gomock.Call { 11703 mr.mock.ctrl.T.Helper() 11704 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsRequest), arg0) 11705 } 11706 11707 // DescribeStaleSecurityGroupsPages mocks base method 11708 func (m *MockEC2API) DescribeStaleSecurityGroupsPages(arg0 *ec2.DescribeStaleSecurityGroupsInput, arg1 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool) error { 11709 m.ctrl.T.Helper() 11710 ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsPages", arg0, arg1) 11711 ret0, _ := ret[0].(error) 11712 return ret0 11713 } 11714 11715 // DescribeStaleSecurityGroupsPages indicates an expected call of DescribeStaleSecurityGroupsPages 11716 func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsPages(arg0, arg1 interface{}) *gomock.Call { 11717 mr.mock.ctrl.T.Helper() 11718 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsPages), arg0, arg1) 11719 } 11720 11721 // DescribeStaleSecurityGroupsPagesWithContext mocks base method 11722 func (m *MockEC2API) DescribeStaleSecurityGroupsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeStaleSecurityGroupsInput, arg2 func(*ec2.DescribeStaleSecurityGroupsOutput, bool) bool, arg3 ...request.Option) error { 11723 m.ctrl.T.Helper() 11724 varargs := []interface{}{arg0, arg1, arg2} 11725 for _, a := range arg3 { 11726 varargs = append(varargs, a) 11727 } 11728 ret := m.ctrl.Call(m, "DescribeStaleSecurityGroupsPagesWithContext", varargs...) 11729 ret0, _ := ret[0].(error) 11730 return ret0 11731 } 11732 11733 // DescribeStaleSecurityGroupsPagesWithContext indicates an expected call of DescribeStaleSecurityGroupsPagesWithContext 11734 func (mr *MockEC2APIMockRecorder) DescribeStaleSecurityGroupsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11735 mr.mock.ctrl.T.Helper() 11736 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11737 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeStaleSecurityGroupsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeStaleSecurityGroupsPagesWithContext), varargs...) 11738 } 11739 11740 // DescribeSubnets mocks base method 11741 func (m *MockEC2API) DescribeSubnets(arg0 *ec2.DescribeSubnetsInput) (*ec2.DescribeSubnetsOutput, error) { 11742 m.ctrl.T.Helper() 11743 ret := m.ctrl.Call(m, "DescribeSubnets", arg0) 11744 ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) 11745 ret1, _ := ret[1].(error) 11746 return ret0, ret1 11747 } 11748 11749 // DescribeSubnets indicates an expected call of DescribeSubnets 11750 func (mr *MockEC2APIMockRecorder) DescribeSubnets(arg0 interface{}) *gomock.Call { 11751 mr.mock.ctrl.T.Helper() 11752 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnets", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnets), arg0) 11753 } 11754 11755 // DescribeSubnetsWithContext mocks base method 11756 func (m *MockEC2API) DescribeSubnetsWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.Option) (*ec2.DescribeSubnetsOutput, error) { 11757 m.ctrl.T.Helper() 11758 varargs := []interface{}{arg0, arg1} 11759 for _, a := range arg2 { 11760 varargs = append(varargs, a) 11761 } 11762 ret := m.ctrl.Call(m, "DescribeSubnetsWithContext", varargs...) 11763 ret0, _ := ret[0].(*ec2.DescribeSubnetsOutput) 11764 ret1, _ := ret[1].(error) 11765 return ret0, ret1 11766 } 11767 11768 // DescribeSubnetsWithContext indicates an expected call of DescribeSubnetsWithContext 11769 func (mr *MockEC2APIMockRecorder) DescribeSubnetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11770 mr.mock.ctrl.T.Helper() 11771 varargs := append([]interface{}{arg0, arg1}, arg2...) 11772 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsWithContext), varargs...) 11773 } 11774 11775 // DescribeSubnetsRequest mocks base method 11776 func (m *MockEC2API) DescribeSubnetsRequest(arg0 *ec2.DescribeSubnetsInput) (*request.Request, *ec2.DescribeSubnetsOutput) { 11777 m.ctrl.T.Helper() 11778 ret := m.ctrl.Call(m, "DescribeSubnetsRequest", arg0) 11779 ret0, _ := ret[0].(*request.Request) 11780 ret1, _ := ret[1].(*ec2.DescribeSubnetsOutput) 11781 return ret0, ret1 11782 } 11783 11784 // DescribeSubnetsRequest indicates an expected call of DescribeSubnetsRequest 11785 func (mr *MockEC2APIMockRecorder) DescribeSubnetsRequest(arg0 interface{}) *gomock.Call { 11786 mr.mock.ctrl.T.Helper() 11787 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsRequest), arg0) 11788 } 11789 11790 // DescribeSubnetsPages mocks base method 11791 func (m *MockEC2API) DescribeSubnetsPages(arg0 *ec2.DescribeSubnetsInput, arg1 func(*ec2.DescribeSubnetsOutput, bool) bool) error { 11792 m.ctrl.T.Helper() 11793 ret := m.ctrl.Call(m, "DescribeSubnetsPages", arg0, arg1) 11794 ret0, _ := ret[0].(error) 11795 return ret0 11796 } 11797 11798 // DescribeSubnetsPages indicates an expected call of DescribeSubnetsPages 11799 func (mr *MockEC2APIMockRecorder) DescribeSubnetsPages(arg0, arg1 interface{}) *gomock.Call { 11800 mr.mock.ctrl.T.Helper() 11801 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPages), arg0, arg1) 11802 } 11803 11804 // DescribeSubnetsPagesWithContext mocks base method 11805 func (m *MockEC2API) DescribeSubnetsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 func(*ec2.DescribeSubnetsOutput, bool) bool, arg3 ...request.Option) error { 11806 m.ctrl.T.Helper() 11807 varargs := []interface{}{arg0, arg1, arg2} 11808 for _, a := range arg3 { 11809 varargs = append(varargs, a) 11810 } 11811 ret := m.ctrl.Call(m, "DescribeSubnetsPagesWithContext", varargs...) 11812 ret0, _ := ret[0].(error) 11813 return ret0 11814 } 11815 11816 // DescribeSubnetsPagesWithContext indicates an expected call of DescribeSubnetsPagesWithContext 11817 func (mr *MockEC2APIMockRecorder) DescribeSubnetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11818 mr.mock.ctrl.T.Helper() 11819 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeSubnetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeSubnetsPagesWithContext), varargs...) 11821 } 11822 11823 // DescribeTags mocks base method 11824 func (m *MockEC2API) DescribeTags(arg0 *ec2.DescribeTagsInput) (*ec2.DescribeTagsOutput, error) { 11825 m.ctrl.T.Helper() 11826 ret := m.ctrl.Call(m, "DescribeTags", arg0) 11827 ret0, _ := ret[0].(*ec2.DescribeTagsOutput) 11828 ret1, _ := ret[1].(error) 11829 return ret0, ret1 11830 } 11831 11832 // DescribeTags indicates an expected call of DescribeTags 11833 func (mr *MockEC2APIMockRecorder) DescribeTags(arg0 interface{}) *gomock.Call { 11834 mr.mock.ctrl.T.Helper() 11835 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTags", reflect.TypeOf((*MockEC2API)(nil).DescribeTags), arg0) 11836 } 11837 11838 // DescribeTagsWithContext mocks base method 11839 func (m *MockEC2API) DescribeTagsWithContext(arg0 aws.Context, arg1 *ec2.DescribeTagsInput, arg2 ...request.Option) (*ec2.DescribeTagsOutput, error) { 11840 m.ctrl.T.Helper() 11841 varargs := []interface{}{arg0, arg1} 11842 for _, a := range arg2 { 11843 varargs = append(varargs, a) 11844 } 11845 ret := m.ctrl.Call(m, "DescribeTagsWithContext", varargs...) 11846 ret0, _ := ret[0].(*ec2.DescribeTagsOutput) 11847 ret1, _ := ret[1].(error) 11848 return ret0, ret1 11849 } 11850 11851 // DescribeTagsWithContext indicates an expected call of DescribeTagsWithContext 11852 func (mr *MockEC2APIMockRecorder) DescribeTagsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11853 mr.mock.ctrl.T.Helper() 11854 varargs := append([]interface{}{arg0, arg1}, arg2...) 11855 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsWithContext), varargs...) 11856 } 11857 11858 // DescribeTagsRequest mocks base method 11859 func (m *MockEC2API) DescribeTagsRequest(arg0 *ec2.DescribeTagsInput) (*request.Request, *ec2.DescribeTagsOutput) { 11860 m.ctrl.T.Helper() 11861 ret := m.ctrl.Call(m, "DescribeTagsRequest", arg0) 11862 ret0, _ := ret[0].(*request.Request) 11863 ret1, _ := ret[1].(*ec2.DescribeTagsOutput) 11864 return ret0, ret1 11865 } 11866 11867 // DescribeTagsRequest indicates an expected call of DescribeTagsRequest 11868 func (mr *MockEC2APIMockRecorder) DescribeTagsRequest(arg0 interface{}) *gomock.Call { 11869 mr.mock.ctrl.T.Helper() 11870 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsRequest), arg0) 11871 } 11872 11873 // DescribeTagsPages mocks base method 11874 func (m *MockEC2API) DescribeTagsPages(arg0 *ec2.DescribeTagsInput, arg1 func(*ec2.DescribeTagsOutput, bool) bool) error { 11875 m.ctrl.T.Helper() 11876 ret := m.ctrl.Call(m, "DescribeTagsPages", arg0, arg1) 11877 ret0, _ := ret[0].(error) 11878 return ret0 11879 } 11880 11881 // DescribeTagsPages indicates an expected call of DescribeTagsPages 11882 func (mr *MockEC2APIMockRecorder) DescribeTagsPages(arg0, arg1 interface{}) *gomock.Call { 11883 mr.mock.ctrl.T.Helper() 11884 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPages), arg0, arg1) 11885 } 11886 11887 // DescribeTagsPagesWithContext mocks base method 11888 func (m *MockEC2API) DescribeTagsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTagsInput, arg2 func(*ec2.DescribeTagsOutput, bool) bool, arg3 ...request.Option) error { 11889 m.ctrl.T.Helper() 11890 varargs := []interface{}{arg0, arg1, arg2} 11891 for _, a := range arg3 { 11892 varargs = append(varargs, a) 11893 } 11894 ret := m.ctrl.Call(m, "DescribeTagsPagesWithContext", varargs...) 11895 ret0, _ := ret[0].(error) 11896 return ret0 11897 } 11898 11899 // DescribeTagsPagesWithContext indicates an expected call of DescribeTagsPagesWithContext 11900 func (mr *MockEC2APIMockRecorder) DescribeTagsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11901 mr.mock.ctrl.T.Helper() 11902 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11903 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTagsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTagsPagesWithContext), varargs...) 11904 } 11905 11906 // DescribeTrafficMirrorFilters mocks base method 11907 func (m *MockEC2API) DescribeTrafficMirrorFilters(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*ec2.DescribeTrafficMirrorFiltersOutput, error) { 11908 m.ctrl.T.Helper() 11909 ret := m.ctrl.Call(m, "DescribeTrafficMirrorFilters", arg0) 11910 ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput) 11911 ret1, _ := ret[1].(error) 11912 return ret0, ret1 11913 } 11914 11915 // DescribeTrafficMirrorFilters indicates an expected call of DescribeTrafficMirrorFilters 11916 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFilters(arg0 interface{}) *gomock.Call { 11917 mr.mock.ctrl.T.Helper() 11918 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFilters", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFilters), arg0) 11919 } 11920 11921 // DescribeTrafficMirrorFiltersWithContext mocks base method 11922 func (m *MockEC2API) DescribeTrafficMirrorFiltersWithContext(arg0 aws.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorFiltersOutput, error) { 11923 m.ctrl.T.Helper() 11924 varargs := []interface{}{arg0, arg1} 11925 for _, a := range arg2 { 11926 varargs = append(varargs, a) 11927 } 11928 ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersWithContext", varargs...) 11929 ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorFiltersOutput) 11930 ret1, _ := ret[1].(error) 11931 return ret0, ret1 11932 } 11933 11934 // DescribeTrafficMirrorFiltersWithContext indicates an expected call of DescribeTrafficMirrorFiltersWithContext 11935 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 11936 mr.mock.ctrl.T.Helper() 11937 varargs := append([]interface{}{arg0, arg1}, arg2...) 11938 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersWithContext), varargs...) 11939 } 11940 11941 // DescribeTrafficMirrorFiltersRequest mocks base method 11942 func (m *MockEC2API) DescribeTrafficMirrorFiltersRequest(arg0 *ec2.DescribeTrafficMirrorFiltersInput) (*request.Request, *ec2.DescribeTrafficMirrorFiltersOutput) { 11943 m.ctrl.T.Helper() 11944 ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersRequest", arg0) 11945 ret0, _ := ret[0].(*request.Request) 11946 ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorFiltersOutput) 11947 return ret0, ret1 11948 } 11949 11950 // DescribeTrafficMirrorFiltersRequest indicates an expected call of DescribeTrafficMirrorFiltersRequest 11951 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersRequest(arg0 interface{}) *gomock.Call { 11952 mr.mock.ctrl.T.Helper() 11953 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersRequest), arg0) 11954 } 11955 11956 // DescribeTrafficMirrorFiltersPages mocks base method 11957 func (m *MockEC2API) DescribeTrafficMirrorFiltersPages(arg0 *ec2.DescribeTrafficMirrorFiltersInput, arg1 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool) error { 11958 m.ctrl.T.Helper() 11959 ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersPages", arg0, arg1) 11960 ret0, _ := ret[0].(error) 11961 return ret0 11962 } 11963 11964 // DescribeTrafficMirrorFiltersPages indicates an expected call of DescribeTrafficMirrorFiltersPages 11965 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersPages(arg0, arg1 interface{}) *gomock.Call { 11966 mr.mock.ctrl.T.Helper() 11967 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPages), arg0, arg1) 11968 } 11969 11970 // DescribeTrafficMirrorFiltersPagesWithContext mocks base method 11971 func (m *MockEC2API) DescribeTrafficMirrorFiltersPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTrafficMirrorFiltersInput, arg2 func(*ec2.DescribeTrafficMirrorFiltersOutput, bool) bool, arg3 ...request.Option) error { 11972 m.ctrl.T.Helper() 11973 varargs := []interface{}{arg0, arg1, arg2} 11974 for _, a := range arg3 { 11975 varargs = append(varargs, a) 11976 } 11977 ret := m.ctrl.Call(m, "DescribeTrafficMirrorFiltersPagesWithContext", varargs...) 11978 ret0, _ := ret[0].(error) 11979 return ret0 11980 } 11981 11982 // DescribeTrafficMirrorFiltersPagesWithContext indicates an expected call of DescribeTrafficMirrorFiltersPagesWithContext 11983 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorFiltersPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 11984 mr.mock.ctrl.T.Helper() 11985 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 11986 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorFiltersPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorFiltersPagesWithContext), varargs...) 11987 } 11988 11989 // DescribeTrafficMirrorSessions mocks base method 11990 func (m *MockEC2API) DescribeTrafficMirrorSessions(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*ec2.DescribeTrafficMirrorSessionsOutput, error) { 11991 m.ctrl.T.Helper() 11992 ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessions", arg0) 11993 ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput) 11994 ret1, _ := ret[1].(error) 11995 return ret0, ret1 11996 } 11997 11998 // DescribeTrafficMirrorSessions indicates an expected call of DescribeTrafficMirrorSessions 11999 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessions(arg0 interface{}) *gomock.Call { 12000 mr.mock.ctrl.T.Helper() 12001 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessions", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessions), arg0) 12002 } 12003 12004 // DescribeTrafficMirrorSessionsWithContext mocks base method 12005 func (m *MockEC2API) DescribeTrafficMirrorSessionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorSessionsOutput, error) { 12006 m.ctrl.T.Helper() 12007 varargs := []interface{}{arg0, arg1} 12008 for _, a := range arg2 { 12009 varargs = append(varargs, a) 12010 } 12011 ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsWithContext", varargs...) 12012 ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorSessionsOutput) 12013 ret1, _ := ret[1].(error) 12014 return ret0, ret1 12015 } 12016 12017 // DescribeTrafficMirrorSessionsWithContext indicates an expected call of DescribeTrafficMirrorSessionsWithContext 12018 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12019 mr.mock.ctrl.T.Helper() 12020 varargs := append([]interface{}{arg0, arg1}, arg2...) 12021 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsWithContext), varargs...) 12022 } 12023 12024 // DescribeTrafficMirrorSessionsRequest mocks base method 12025 func (m *MockEC2API) DescribeTrafficMirrorSessionsRequest(arg0 *ec2.DescribeTrafficMirrorSessionsInput) (*request.Request, *ec2.DescribeTrafficMirrorSessionsOutput) { 12026 m.ctrl.T.Helper() 12027 ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsRequest", arg0) 12028 ret0, _ := ret[0].(*request.Request) 12029 ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorSessionsOutput) 12030 return ret0, ret1 12031 } 12032 12033 // DescribeTrafficMirrorSessionsRequest indicates an expected call of DescribeTrafficMirrorSessionsRequest 12034 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsRequest(arg0 interface{}) *gomock.Call { 12035 mr.mock.ctrl.T.Helper() 12036 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsRequest), arg0) 12037 } 12038 12039 // DescribeTrafficMirrorSessionsPages mocks base method 12040 func (m *MockEC2API) DescribeTrafficMirrorSessionsPages(arg0 *ec2.DescribeTrafficMirrorSessionsInput, arg1 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool) error { 12041 m.ctrl.T.Helper() 12042 ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsPages", arg0, arg1) 12043 ret0, _ := ret[0].(error) 12044 return ret0 12045 } 12046 12047 // DescribeTrafficMirrorSessionsPages indicates an expected call of DescribeTrafficMirrorSessionsPages 12048 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsPages(arg0, arg1 interface{}) *gomock.Call { 12049 mr.mock.ctrl.T.Helper() 12050 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPages), arg0, arg1) 12051 } 12052 12053 // DescribeTrafficMirrorSessionsPagesWithContext mocks base method 12054 func (m *MockEC2API) DescribeTrafficMirrorSessionsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTrafficMirrorSessionsInput, arg2 func(*ec2.DescribeTrafficMirrorSessionsOutput, bool) bool, arg3 ...request.Option) error { 12055 m.ctrl.T.Helper() 12056 varargs := []interface{}{arg0, arg1, arg2} 12057 for _, a := range arg3 { 12058 varargs = append(varargs, a) 12059 } 12060 ret := m.ctrl.Call(m, "DescribeTrafficMirrorSessionsPagesWithContext", varargs...) 12061 ret0, _ := ret[0].(error) 12062 return ret0 12063 } 12064 12065 // DescribeTrafficMirrorSessionsPagesWithContext indicates an expected call of DescribeTrafficMirrorSessionsPagesWithContext 12066 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorSessionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12067 mr.mock.ctrl.T.Helper() 12068 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12069 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorSessionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorSessionsPagesWithContext), varargs...) 12070 } 12071 12072 // DescribeTrafficMirrorTargets mocks base method 12073 func (m *MockEC2API) DescribeTrafficMirrorTargets(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*ec2.DescribeTrafficMirrorTargetsOutput, error) { 12074 m.ctrl.T.Helper() 12075 ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargets", arg0) 12076 ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput) 12077 ret1, _ := ret[1].(error) 12078 return ret0, ret1 12079 } 12080 12081 // DescribeTrafficMirrorTargets indicates an expected call of DescribeTrafficMirrorTargets 12082 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargets(arg0 interface{}) *gomock.Call { 12083 mr.mock.ctrl.T.Helper() 12084 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargets", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargets), arg0) 12085 } 12086 12087 // DescribeTrafficMirrorTargetsWithContext mocks base method 12088 func (m *MockEC2API) DescribeTrafficMirrorTargetsWithContext(arg0 aws.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 ...request.Option) (*ec2.DescribeTrafficMirrorTargetsOutput, error) { 12089 m.ctrl.T.Helper() 12090 varargs := []interface{}{arg0, arg1} 12091 for _, a := range arg2 { 12092 varargs = append(varargs, a) 12093 } 12094 ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsWithContext", varargs...) 12095 ret0, _ := ret[0].(*ec2.DescribeTrafficMirrorTargetsOutput) 12096 ret1, _ := ret[1].(error) 12097 return ret0, ret1 12098 } 12099 12100 // DescribeTrafficMirrorTargetsWithContext indicates an expected call of DescribeTrafficMirrorTargetsWithContext 12101 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12102 mr.mock.ctrl.T.Helper() 12103 varargs := append([]interface{}{arg0, arg1}, arg2...) 12104 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsWithContext), varargs...) 12105 } 12106 12107 // DescribeTrafficMirrorTargetsRequest mocks base method 12108 func (m *MockEC2API) DescribeTrafficMirrorTargetsRequest(arg0 *ec2.DescribeTrafficMirrorTargetsInput) (*request.Request, *ec2.DescribeTrafficMirrorTargetsOutput) { 12109 m.ctrl.T.Helper() 12110 ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsRequest", arg0) 12111 ret0, _ := ret[0].(*request.Request) 12112 ret1, _ := ret[1].(*ec2.DescribeTrafficMirrorTargetsOutput) 12113 return ret0, ret1 12114 } 12115 12116 // DescribeTrafficMirrorTargetsRequest indicates an expected call of DescribeTrafficMirrorTargetsRequest 12117 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsRequest(arg0 interface{}) *gomock.Call { 12118 mr.mock.ctrl.T.Helper() 12119 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsRequest), arg0) 12120 } 12121 12122 // DescribeTrafficMirrorTargetsPages mocks base method 12123 func (m *MockEC2API) DescribeTrafficMirrorTargetsPages(arg0 *ec2.DescribeTrafficMirrorTargetsInput, arg1 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool) error { 12124 m.ctrl.T.Helper() 12125 ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPages", arg0, arg1) 12126 ret0, _ := ret[0].(error) 12127 return ret0 12128 } 12129 12130 // DescribeTrafficMirrorTargetsPages indicates an expected call of DescribeTrafficMirrorTargetsPages 12131 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPages(arg0, arg1 interface{}) *gomock.Call { 12132 mr.mock.ctrl.T.Helper() 12133 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPages), arg0, arg1) 12134 } 12135 12136 // DescribeTrafficMirrorTargetsPagesWithContext mocks base method 12137 func (m *MockEC2API) DescribeTrafficMirrorTargetsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTrafficMirrorTargetsInput, arg2 func(*ec2.DescribeTrafficMirrorTargetsOutput, bool) bool, arg3 ...request.Option) error { 12138 m.ctrl.T.Helper() 12139 varargs := []interface{}{arg0, arg1, arg2} 12140 for _, a := range arg3 { 12141 varargs = append(varargs, a) 12142 } 12143 ret := m.ctrl.Call(m, "DescribeTrafficMirrorTargetsPagesWithContext", varargs...) 12144 ret0, _ := ret[0].(error) 12145 return ret0 12146 } 12147 12148 // DescribeTrafficMirrorTargetsPagesWithContext indicates an expected call of DescribeTrafficMirrorTargetsPagesWithContext 12149 func (mr *MockEC2APIMockRecorder) DescribeTrafficMirrorTargetsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12150 mr.mock.ctrl.T.Helper() 12151 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12152 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTrafficMirrorTargetsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTrafficMirrorTargetsPagesWithContext), varargs...) 12153 } 12154 12155 // DescribeTransitGatewayAttachments mocks base method 12156 func (m *MockEC2API) DescribeTransitGatewayAttachments(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) { 12157 m.ctrl.T.Helper() 12158 ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachments", arg0) 12159 ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput) 12160 ret1, _ := ret[1].(error) 12161 return ret0, ret1 12162 } 12163 12164 // DescribeTransitGatewayAttachments indicates an expected call of DescribeTransitGatewayAttachments 12165 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachments(arg0 interface{}) *gomock.Call { 12166 mr.mock.ctrl.T.Helper() 12167 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachments), arg0) 12168 } 12169 12170 // DescribeTransitGatewayAttachmentsWithContext mocks base method 12171 func (m *MockEC2API) DescribeTransitGatewayAttachmentsWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayAttachmentsOutput, error) { 12172 m.ctrl.T.Helper() 12173 varargs := []interface{}{arg0, arg1} 12174 for _, a := range arg2 { 12175 varargs = append(varargs, a) 12176 } 12177 ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsWithContext", varargs...) 12178 ret0, _ := ret[0].(*ec2.DescribeTransitGatewayAttachmentsOutput) 12179 ret1, _ := ret[1].(error) 12180 return ret0, ret1 12181 } 12182 12183 // DescribeTransitGatewayAttachmentsWithContext indicates an expected call of DescribeTransitGatewayAttachmentsWithContext 12184 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12185 mr.mock.ctrl.T.Helper() 12186 varargs := append([]interface{}{arg0, arg1}, arg2...) 12187 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsWithContext), varargs...) 12188 } 12189 12190 // DescribeTransitGatewayAttachmentsRequest mocks base method 12191 func (m *MockEC2API) DescribeTransitGatewayAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayAttachmentsOutput) { 12192 m.ctrl.T.Helper() 12193 ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsRequest", arg0) 12194 ret0, _ := ret[0].(*request.Request) 12195 ret1, _ := ret[1].(*ec2.DescribeTransitGatewayAttachmentsOutput) 12196 return ret0, ret1 12197 } 12198 12199 // DescribeTransitGatewayAttachmentsRequest indicates an expected call of DescribeTransitGatewayAttachmentsRequest 12200 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsRequest(arg0 interface{}) *gomock.Call { 12201 mr.mock.ctrl.T.Helper() 12202 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsRequest), arg0) 12203 } 12204 12205 // DescribeTransitGatewayAttachmentsPages mocks base method 12206 func (m *MockEC2API) DescribeTransitGatewayAttachmentsPages(arg0 *ec2.DescribeTransitGatewayAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool) error { 12207 m.ctrl.T.Helper() 12208 ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsPages", arg0, arg1) 12209 ret0, _ := ret[0].(error) 12210 return ret0 12211 } 12212 12213 // DescribeTransitGatewayAttachmentsPages indicates an expected call of DescribeTransitGatewayAttachmentsPages 12214 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { 12215 mr.mock.ctrl.T.Helper() 12216 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPages), arg0, arg1) 12217 } 12218 12219 // DescribeTransitGatewayAttachmentsPagesWithContext mocks base method 12220 func (m *MockEC2API) DescribeTransitGatewayAttachmentsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayAttachmentsOutput, bool) bool, arg3 ...request.Option) error { 12221 m.ctrl.T.Helper() 12222 varargs := []interface{}{arg0, arg1, arg2} 12223 for _, a := range arg3 { 12224 varargs = append(varargs, a) 12225 } 12226 ret := m.ctrl.Call(m, "DescribeTransitGatewayAttachmentsPagesWithContext", varargs...) 12227 ret0, _ := ret[0].(error) 12228 return ret0 12229 } 12230 12231 // DescribeTransitGatewayAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayAttachmentsPagesWithContext 12232 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayAttachmentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12233 mr.mock.ctrl.T.Helper() 12234 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12235 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayAttachmentsPagesWithContext), varargs...) 12236 } 12237 12238 // DescribeTransitGatewayRouteTables mocks base method 12239 func (m *MockEC2API) DescribeTransitGatewayRouteTables(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) { 12240 m.ctrl.T.Helper() 12241 ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTables", arg0) 12242 ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput) 12243 ret1, _ := ret[1].(error) 12244 return ret0, ret1 12245 } 12246 12247 // DescribeTransitGatewayRouteTables indicates an expected call of DescribeTransitGatewayRouteTables 12248 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTables(arg0 interface{}) *gomock.Call { 12249 mr.mock.ctrl.T.Helper() 12250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTables", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTables), arg0) 12251 } 12252 12253 // DescribeTransitGatewayRouteTablesWithContext mocks base method 12254 func (m *MockEC2API) DescribeTransitGatewayRouteTablesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayRouteTablesOutput, error) { 12255 m.ctrl.T.Helper() 12256 varargs := []interface{}{arg0, arg1} 12257 for _, a := range arg2 { 12258 varargs = append(varargs, a) 12259 } 12260 ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesWithContext", varargs...) 12261 ret0, _ := ret[0].(*ec2.DescribeTransitGatewayRouteTablesOutput) 12262 ret1, _ := ret[1].(error) 12263 return ret0, ret1 12264 } 12265 12266 // DescribeTransitGatewayRouteTablesWithContext indicates an expected call of DescribeTransitGatewayRouteTablesWithContext 12267 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12268 mr.mock.ctrl.T.Helper() 12269 varargs := append([]interface{}{arg0, arg1}, arg2...) 12270 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesWithContext), varargs...) 12271 } 12272 12273 // DescribeTransitGatewayRouteTablesRequest mocks base method 12274 func (m *MockEC2API) DescribeTransitGatewayRouteTablesRequest(arg0 *ec2.DescribeTransitGatewayRouteTablesInput) (*request.Request, *ec2.DescribeTransitGatewayRouteTablesOutput) { 12275 m.ctrl.T.Helper() 12276 ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesRequest", arg0) 12277 ret0, _ := ret[0].(*request.Request) 12278 ret1, _ := ret[1].(*ec2.DescribeTransitGatewayRouteTablesOutput) 12279 return ret0, ret1 12280 } 12281 12282 // DescribeTransitGatewayRouteTablesRequest indicates an expected call of DescribeTransitGatewayRouteTablesRequest 12283 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesRequest(arg0 interface{}) *gomock.Call { 12284 mr.mock.ctrl.T.Helper() 12285 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesRequest), arg0) 12286 } 12287 12288 // DescribeTransitGatewayRouteTablesPages mocks base method 12289 func (m *MockEC2API) DescribeTransitGatewayRouteTablesPages(arg0 *ec2.DescribeTransitGatewayRouteTablesInput, arg1 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool) error { 12290 m.ctrl.T.Helper() 12291 ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesPages", arg0, arg1) 12292 ret0, _ := ret[0].(error) 12293 return ret0 12294 } 12295 12296 // DescribeTransitGatewayRouteTablesPages indicates an expected call of DescribeTransitGatewayRouteTablesPages 12297 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesPages(arg0, arg1 interface{}) *gomock.Call { 12298 mr.mock.ctrl.T.Helper() 12299 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPages), arg0, arg1) 12300 } 12301 12302 // DescribeTransitGatewayRouteTablesPagesWithContext mocks base method 12303 func (m *MockEC2API) DescribeTransitGatewayRouteTablesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayRouteTablesInput, arg2 func(*ec2.DescribeTransitGatewayRouteTablesOutput, bool) bool, arg3 ...request.Option) error { 12304 m.ctrl.T.Helper() 12305 varargs := []interface{}{arg0, arg1, arg2} 12306 for _, a := range arg3 { 12307 varargs = append(varargs, a) 12308 } 12309 ret := m.ctrl.Call(m, "DescribeTransitGatewayRouteTablesPagesWithContext", varargs...) 12310 ret0, _ := ret[0].(error) 12311 return ret0 12312 } 12313 12314 // DescribeTransitGatewayRouteTablesPagesWithContext indicates an expected call of DescribeTransitGatewayRouteTablesPagesWithContext 12315 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayRouteTablesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12316 mr.mock.ctrl.T.Helper() 12317 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12318 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayRouteTablesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayRouteTablesPagesWithContext), varargs...) 12319 } 12320 12321 // DescribeTransitGatewayVpcAttachments mocks base method 12322 func (m *MockEC2API) DescribeTransitGatewayVpcAttachments(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) { 12323 m.ctrl.T.Helper() 12324 ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachments", arg0) 12325 ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) 12326 ret1, _ := ret[1].(error) 12327 return ret0, ret1 12328 } 12329 12330 // DescribeTransitGatewayVpcAttachments indicates an expected call of DescribeTransitGatewayVpcAttachments 12331 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachments(arg0 interface{}) *gomock.Call { 12332 mr.mock.ctrl.T.Helper() 12333 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachments", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachments), arg0) 12334 } 12335 12336 // DescribeTransitGatewayVpcAttachmentsWithContext mocks base method 12337 func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewayVpcAttachmentsOutput, error) { 12338 m.ctrl.T.Helper() 12339 varargs := []interface{}{arg0, arg1} 12340 for _, a := range arg2 { 12341 varargs = append(varargs, a) 12342 } 12343 ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsWithContext", varargs...) 12344 ret0, _ := ret[0].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) 12345 ret1, _ := ret[1].(error) 12346 return ret0, ret1 12347 } 12348 12349 // DescribeTransitGatewayVpcAttachmentsWithContext indicates an expected call of DescribeTransitGatewayVpcAttachmentsWithContext 12350 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12351 mr.mock.ctrl.T.Helper() 12352 varargs := append([]interface{}{arg0, arg1}, arg2...) 12353 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsWithContext), varargs...) 12354 } 12355 12356 // DescribeTransitGatewayVpcAttachmentsRequest mocks base method 12357 func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsRequest(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput) (*request.Request, *ec2.DescribeTransitGatewayVpcAttachmentsOutput) { 12358 m.ctrl.T.Helper() 12359 ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsRequest", arg0) 12360 ret0, _ := ret[0].(*request.Request) 12361 ret1, _ := ret[1].(*ec2.DescribeTransitGatewayVpcAttachmentsOutput) 12362 return ret0, ret1 12363 } 12364 12365 // DescribeTransitGatewayVpcAttachmentsRequest indicates an expected call of DescribeTransitGatewayVpcAttachmentsRequest 12366 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsRequest(arg0 interface{}) *gomock.Call { 12367 mr.mock.ctrl.T.Helper() 12368 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsRequest), arg0) 12369 } 12370 12371 // DescribeTransitGatewayVpcAttachmentsPages mocks base method 12372 func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPages(arg0 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg1 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool) error { 12373 m.ctrl.T.Helper() 12374 ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsPages", arg0, arg1) 12375 ret0, _ := ret[0].(error) 12376 return ret0 12377 } 12378 12379 // DescribeTransitGatewayVpcAttachmentsPages indicates an expected call of DescribeTransitGatewayVpcAttachmentsPages 12380 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsPages(arg0, arg1 interface{}) *gomock.Call { 12381 mr.mock.ctrl.T.Helper() 12382 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPages), arg0, arg1) 12383 } 12384 12385 // DescribeTransitGatewayVpcAttachmentsPagesWithContext mocks base method 12386 func (m *MockEC2API) DescribeTransitGatewayVpcAttachmentsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewayVpcAttachmentsInput, arg2 func(*ec2.DescribeTransitGatewayVpcAttachmentsOutput, bool) bool, arg3 ...request.Option) error { 12387 m.ctrl.T.Helper() 12388 varargs := []interface{}{arg0, arg1, arg2} 12389 for _, a := range arg3 { 12390 varargs = append(varargs, a) 12391 } 12392 ret := m.ctrl.Call(m, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", varargs...) 12393 ret0, _ := ret[0].(error) 12394 return ret0 12395 } 12396 12397 // DescribeTransitGatewayVpcAttachmentsPagesWithContext indicates an expected call of DescribeTransitGatewayVpcAttachmentsPagesWithContext 12398 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewayVpcAttachmentsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12399 mr.mock.ctrl.T.Helper() 12400 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12401 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewayVpcAttachmentsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewayVpcAttachmentsPagesWithContext), varargs...) 12402 } 12403 12404 // DescribeTransitGateways mocks base method 12405 func (m *MockEC2API) DescribeTransitGateways(arg0 *ec2.DescribeTransitGatewaysInput) (*ec2.DescribeTransitGatewaysOutput, error) { 12406 m.ctrl.T.Helper() 12407 ret := m.ctrl.Call(m, "DescribeTransitGateways", arg0) 12408 ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput) 12409 ret1, _ := ret[1].(error) 12410 return ret0, ret1 12411 } 12412 12413 // DescribeTransitGateways indicates an expected call of DescribeTransitGateways 12414 func (mr *MockEC2APIMockRecorder) DescribeTransitGateways(arg0 interface{}) *gomock.Call { 12415 mr.mock.ctrl.T.Helper() 12416 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGateways), arg0) 12417 } 12418 12419 // DescribeTransitGatewaysWithContext mocks base method 12420 func (m *MockEC2API) DescribeTransitGatewaysWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 ...request.Option) (*ec2.DescribeTransitGatewaysOutput, error) { 12421 m.ctrl.T.Helper() 12422 varargs := []interface{}{arg0, arg1} 12423 for _, a := range arg2 { 12424 varargs = append(varargs, a) 12425 } 12426 ret := m.ctrl.Call(m, "DescribeTransitGatewaysWithContext", varargs...) 12427 ret0, _ := ret[0].(*ec2.DescribeTransitGatewaysOutput) 12428 ret1, _ := ret[1].(error) 12429 return ret0, ret1 12430 } 12431 12432 // DescribeTransitGatewaysWithContext indicates an expected call of DescribeTransitGatewaysWithContext 12433 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12434 mr.mock.ctrl.T.Helper() 12435 varargs := append([]interface{}{arg0, arg1}, arg2...) 12436 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysWithContext), varargs...) 12437 } 12438 12439 // DescribeTransitGatewaysRequest mocks base method 12440 func (m *MockEC2API) DescribeTransitGatewaysRequest(arg0 *ec2.DescribeTransitGatewaysInput) (*request.Request, *ec2.DescribeTransitGatewaysOutput) { 12441 m.ctrl.T.Helper() 12442 ret := m.ctrl.Call(m, "DescribeTransitGatewaysRequest", arg0) 12443 ret0, _ := ret[0].(*request.Request) 12444 ret1, _ := ret[1].(*ec2.DescribeTransitGatewaysOutput) 12445 return ret0, ret1 12446 } 12447 12448 // DescribeTransitGatewaysRequest indicates an expected call of DescribeTransitGatewaysRequest 12449 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysRequest(arg0 interface{}) *gomock.Call { 12450 mr.mock.ctrl.T.Helper() 12451 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysRequest), arg0) 12452 } 12453 12454 // DescribeTransitGatewaysPages mocks base method 12455 func (m *MockEC2API) DescribeTransitGatewaysPages(arg0 *ec2.DescribeTransitGatewaysInput, arg1 func(*ec2.DescribeTransitGatewaysOutput, bool) bool) error { 12456 m.ctrl.T.Helper() 12457 ret := m.ctrl.Call(m, "DescribeTransitGatewaysPages", arg0, arg1) 12458 ret0, _ := ret[0].(error) 12459 return ret0 12460 } 12461 12462 // DescribeTransitGatewaysPages indicates an expected call of DescribeTransitGatewaysPages 12463 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysPages(arg0, arg1 interface{}) *gomock.Call { 12464 mr.mock.ctrl.T.Helper() 12465 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysPages", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysPages), arg0, arg1) 12466 } 12467 12468 // DescribeTransitGatewaysPagesWithContext mocks base method 12469 func (m *MockEC2API) DescribeTransitGatewaysPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeTransitGatewaysInput, arg2 func(*ec2.DescribeTransitGatewaysOutput, bool) bool, arg3 ...request.Option) error { 12470 m.ctrl.T.Helper() 12471 varargs := []interface{}{arg0, arg1, arg2} 12472 for _, a := range arg3 { 12473 varargs = append(varargs, a) 12474 } 12475 ret := m.ctrl.Call(m, "DescribeTransitGatewaysPagesWithContext", varargs...) 12476 ret0, _ := ret[0].(error) 12477 return ret0 12478 } 12479 12480 // DescribeTransitGatewaysPagesWithContext indicates an expected call of DescribeTransitGatewaysPagesWithContext 12481 func (mr *MockEC2APIMockRecorder) DescribeTransitGatewaysPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12482 mr.mock.ctrl.T.Helper() 12483 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12484 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeTransitGatewaysPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeTransitGatewaysPagesWithContext), varargs...) 12485 } 12486 12487 // DescribeVolumeAttribute mocks base method 12488 func (m *MockEC2API) DescribeVolumeAttribute(arg0 *ec2.DescribeVolumeAttributeInput) (*ec2.DescribeVolumeAttributeOutput, error) { 12489 m.ctrl.T.Helper() 12490 ret := m.ctrl.Call(m, "DescribeVolumeAttribute", arg0) 12491 ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput) 12492 ret1, _ := ret[1].(error) 12493 return ret0, ret1 12494 } 12495 12496 // DescribeVolumeAttribute indicates an expected call of DescribeVolumeAttribute 12497 func (mr *MockEC2APIMockRecorder) DescribeVolumeAttribute(arg0 interface{}) *gomock.Call { 12498 mr.mock.ctrl.T.Helper() 12499 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttribute), arg0) 12500 } 12501 12502 // DescribeVolumeAttributeWithContext mocks base method 12503 func (m *MockEC2API) DescribeVolumeAttributeWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumeAttributeInput, arg2 ...request.Option) (*ec2.DescribeVolumeAttributeOutput, error) { 12504 m.ctrl.T.Helper() 12505 varargs := []interface{}{arg0, arg1} 12506 for _, a := range arg2 { 12507 varargs = append(varargs, a) 12508 } 12509 ret := m.ctrl.Call(m, "DescribeVolumeAttributeWithContext", varargs...) 12510 ret0, _ := ret[0].(*ec2.DescribeVolumeAttributeOutput) 12511 ret1, _ := ret[1].(error) 12512 return ret0, ret1 12513 } 12514 12515 // DescribeVolumeAttributeWithContext indicates an expected call of DescribeVolumeAttributeWithContext 12516 func (mr *MockEC2APIMockRecorder) DescribeVolumeAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12517 mr.mock.ctrl.T.Helper() 12518 varargs := append([]interface{}{arg0, arg1}, arg2...) 12519 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttributeWithContext), varargs...) 12520 } 12521 12522 // DescribeVolumeAttributeRequest mocks base method 12523 func (m *MockEC2API) DescribeVolumeAttributeRequest(arg0 *ec2.DescribeVolumeAttributeInput) (*request.Request, *ec2.DescribeVolumeAttributeOutput) { 12524 m.ctrl.T.Helper() 12525 ret := m.ctrl.Call(m, "DescribeVolumeAttributeRequest", arg0) 12526 ret0, _ := ret[0].(*request.Request) 12527 ret1, _ := ret[1].(*ec2.DescribeVolumeAttributeOutput) 12528 return ret0, ret1 12529 } 12530 12531 // DescribeVolumeAttributeRequest indicates an expected call of DescribeVolumeAttributeRequest 12532 func (mr *MockEC2APIMockRecorder) DescribeVolumeAttributeRequest(arg0 interface{}) *gomock.Call { 12533 mr.mock.ctrl.T.Helper() 12534 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeAttributeRequest), arg0) 12535 } 12536 12537 // DescribeVolumeStatus mocks base method 12538 func (m *MockEC2API) DescribeVolumeStatus(arg0 *ec2.DescribeVolumeStatusInput) (*ec2.DescribeVolumeStatusOutput, error) { 12539 m.ctrl.T.Helper() 12540 ret := m.ctrl.Call(m, "DescribeVolumeStatus", arg0) 12541 ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput) 12542 ret1, _ := ret[1].(error) 12543 return ret0, ret1 12544 } 12545 12546 // DescribeVolumeStatus indicates an expected call of DescribeVolumeStatus 12547 func (mr *MockEC2APIMockRecorder) DescribeVolumeStatus(arg0 interface{}) *gomock.Call { 12548 mr.mock.ctrl.T.Helper() 12549 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatus", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatus), arg0) 12550 } 12551 12552 // DescribeVolumeStatusWithContext mocks base method 12553 func (m *MockEC2API) DescribeVolumeStatusWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 ...request.Option) (*ec2.DescribeVolumeStatusOutput, error) { 12554 m.ctrl.T.Helper() 12555 varargs := []interface{}{arg0, arg1} 12556 for _, a := range arg2 { 12557 varargs = append(varargs, a) 12558 } 12559 ret := m.ctrl.Call(m, "DescribeVolumeStatusWithContext", varargs...) 12560 ret0, _ := ret[0].(*ec2.DescribeVolumeStatusOutput) 12561 ret1, _ := ret[1].(error) 12562 return ret0, ret1 12563 } 12564 12565 // DescribeVolumeStatusWithContext indicates an expected call of DescribeVolumeStatusWithContext 12566 func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12567 mr.mock.ctrl.T.Helper() 12568 varargs := append([]interface{}{arg0, arg1}, arg2...) 12569 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusWithContext), varargs...) 12570 } 12571 12572 // DescribeVolumeStatusRequest mocks base method 12573 func (m *MockEC2API) DescribeVolumeStatusRequest(arg0 *ec2.DescribeVolumeStatusInput) (*request.Request, *ec2.DescribeVolumeStatusOutput) { 12574 m.ctrl.T.Helper() 12575 ret := m.ctrl.Call(m, "DescribeVolumeStatusRequest", arg0) 12576 ret0, _ := ret[0].(*request.Request) 12577 ret1, _ := ret[1].(*ec2.DescribeVolumeStatusOutput) 12578 return ret0, ret1 12579 } 12580 12581 // DescribeVolumeStatusRequest indicates an expected call of DescribeVolumeStatusRequest 12582 func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusRequest(arg0 interface{}) *gomock.Call { 12583 mr.mock.ctrl.T.Helper() 12584 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusRequest), arg0) 12585 } 12586 12587 // DescribeVolumeStatusPages mocks base method 12588 func (m *MockEC2API) DescribeVolumeStatusPages(arg0 *ec2.DescribeVolumeStatusInput, arg1 func(*ec2.DescribeVolumeStatusOutput, bool) bool) error { 12589 m.ctrl.T.Helper() 12590 ret := m.ctrl.Call(m, "DescribeVolumeStatusPages", arg0, arg1) 12591 ret0, _ := ret[0].(error) 12592 return ret0 12593 } 12594 12595 // DescribeVolumeStatusPages indicates an expected call of DescribeVolumeStatusPages 12596 func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusPages(arg0, arg1 interface{}) *gomock.Call { 12597 mr.mock.ctrl.T.Helper() 12598 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusPages), arg0, arg1) 12599 } 12600 12601 // DescribeVolumeStatusPagesWithContext mocks base method 12602 func (m *MockEC2API) DescribeVolumeStatusPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumeStatusInput, arg2 func(*ec2.DescribeVolumeStatusOutput, bool) bool, arg3 ...request.Option) error { 12603 m.ctrl.T.Helper() 12604 varargs := []interface{}{arg0, arg1, arg2} 12605 for _, a := range arg3 { 12606 varargs = append(varargs, a) 12607 } 12608 ret := m.ctrl.Call(m, "DescribeVolumeStatusPagesWithContext", varargs...) 12609 ret0, _ := ret[0].(error) 12610 return ret0 12611 } 12612 12613 // DescribeVolumeStatusPagesWithContext indicates an expected call of DescribeVolumeStatusPagesWithContext 12614 func (mr *MockEC2APIMockRecorder) DescribeVolumeStatusPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12615 mr.mock.ctrl.T.Helper() 12616 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12617 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumeStatusPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumeStatusPagesWithContext), varargs...) 12618 } 12619 12620 // DescribeVolumes mocks base method 12621 func (m *MockEC2API) DescribeVolumes(arg0 *ec2.DescribeVolumesInput) (*ec2.DescribeVolumesOutput, error) { 12622 m.ctrl.T.Helper() 12623 ret := m.ctrl.Call(m, "DescribeVolumes", arg0) 12624 ret0, _ := ret[0].(*ec2.DescribeVolumesOutput) 12625 ret1, _ := ret[1].(error) 12626 return ret0, ret1 12627 } 12628 12629 // DescribeVolumes indicates an expected call of DescribeVolumes 12630 func (mr *MockEC2APIMockRecorder) DescribeVolumes(arg0 interface{}) *gomock.Call { 12631 mr.mock.ctrl.T.Helper() 12632 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumes", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumes), arg0) 12633 } 12634 12635 // DescribeVolumesWithContext mocks base method 12636 func (m *MockEC2API) DescribeVolumesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.Option) (*ec2.DescribeVolumesOutput, error) { 12637 m.ctrl.T.Helper() 12638 varargs := []interface{}{arg0, arg1} 12639 for _, a := range arg2 { 12640 varargs = append(varargs, a) 12641 } 12642 ret := m.ctrl.Call(m, "DescribeVolumesWithContext", varargs...) 12643 ret0, _ := ret[0].(*ec2.DescribeVolumesOutput) 12644 ret1, _ := ret[1].(error) 12645 return ret0, ret1 12646 } 12647 12648 // DescribeVolumesWithContext indicates an expected call of DescribeVolumesWithContext 12649 func (mr *MockEC2APIMockRecorder) DescribeVolumesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12650 mr.mock.ctrl.T.Helper() 12651 varargs := append([]interface{}{arg0, arg1}, arg2...) 12652 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesWithContext), varargs...) 12653 } 12654 12655 // DescribeVolumesRequest mocks base method 12656 func (m *MockEC2API) DescribeVolumesRequest(arg0 *ec2.DescribeVolumesInput) (*request.Request, *ec2.DescribeVolumesOutput) { 12657 m.ctrl.T.Helper() 12658 ret := m.ctrl.Call(m, "DescribeVolumesRequest", arg0) 12659 ret0, _ := ret[0].(*request.Request) 12660 ret1, _ := ret[1].(*ec2.DescribeVolumesOutput) 12661 return ret0, ret1 12662 } 12663 12664 // DescribeVolumesRequest indicates an expected call of DescribeVolumesRequest 12665 func (mr *MockEC2APIMockRecorder) DescribeVolumesRequest(arg0 interface{}) *gomock.Call { 12666 mr.mock.ctrl.T.Helper() 12667 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesRequest), arg0) 12668 } 12669 12670 // DescribeVolumesPages mocks base method 12671 func (m *MockEC2API) DescribeVolumesPages(arg0 *ec2.DescribeVolumesInput, arg1 func(*ec2.DescribeVolumesOutput, bool) bool) error { 12672 m.ctrl.T.Helper() 12673 ret := m.ctrl.Call(m, "DescribeVolumesPages", arg0, arg1) 12674 ret0, _ := ret[0].(error) 12675 return ret0 12676 } 12677 12678 // DescribeVolumesPages indicates an expected call of DescribeVolumesPages 12679 func (mr *MockEC2APIMockRecorder) DescribeVolumesPages(arg0, arg1 interface{}) *gomock.Call { 12680 mr.mock.ctrl.T.Helper() 12681 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesPages), arg0, arg1) 12682 } 12683 12684 // DescribeVolumesPagesWithContext mocks base method 12685 func (m *MockEC2API) DescribeVolumesPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumesInput, arg2 func(*ec2.DescribeVolumesOutput, bool) bool, arg3 ...request.Option) error { 12686 m.ctrl.T.Helper() 12687 varargs := []interface{}{arg0, arg1, arg2} 12688 for _, a := range arg3 { 12689 varargs = append(varargs, a) 12690 } 12691 ret := m.ctrl.Call(m, "DescribeVolumesPagesWithContext", varargs...) 12692 ret0, _ := ret[0].(error) 12693 return ret0 12694 } 12695 12696 // DescribeVolumesPagesWithContext indicates an expected call of DescribeVolumesPagesWithContext 12697 func (mr *MockEC2APIMockRecorder) DescribeVolumesPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12698 mr.mock.ctrl.T.Helper() 12699 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12700 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesPagesWithContext), varargs...) 12701 } 12702 12703 // DescribeVolumesModifications mocks base method 12704 func (m *MockEC2API) DescribeVolumesModifications(arg0 *ec2.DescribeVolumesModificationsInput) (*ec2.DescribeVolumesModificationsOutput, error) { 12705 m.ctrl.T.Helper() 12706 ret := m.ctrl.Call(m, "DescribeVolumesModifications", arg0) 12707 ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput) 12708 ret1, _ := ret[1].(error) 12709 return ret0, ret1 12710 } 12711 12712 // DescribeVolumesModifications indicates an expected call of DescribeVolumesModifications 12713 func (mr *MockEC2APIMockRecorder) DescribeVolumesModifications(arg0 interface{}) *gomock.Call { 12714 mr.mock.ctrl.T.Helper() 12715 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModifications), arg0) 12716 } 12717 12718 // DescribeVolumesModificationsWithContext mocks base method 12719 func (m *MockEC2API) DescribeVolumesModificationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 ...request.Option) (*ec2.DescribeVolumesModificationsOutput, error) { 12720 m.ctrl.T.Helper() 12721 varargs := []interface{}{arg0, arg1} 12722 for _, a := range arg2 { 12723 varargs = append(varargs, a) 12724 } 12725 ret := m.ctrl.Call(m, "DescribeVolumesModificationsWithContext", varargs...) 12726 ret0, _ := ret[0].(*ec2.DescribeVolumesModificationsOutput) 12727 ret1, _ := ret[1].(error) 12728 return ret0, ret1 12729 } 12730 12731 // DescribeVolumesModificationsWithContext indicates an expected call of DescribeVolumesModificationsWithContext 12732 func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12733 mr.mock.ctrl.T.Helper() 12734 varargs := append([]interface{}{arg0, arg1}, arg2...) 12735 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsWithContext), varargs...) 12736 } 12737 12738 // DescribeVolumesModificationsRequest mocks base method 12739 func (m *MockEC2API) DescribeVolumesModificationsRequest(arg0 *ec2.DescribeVolumesModificationsInput) (*request.Request, *ec2.DescribeVolumesModificationsOutput) { 12740 m.ctrl.T.Helper() 12741 ret := m.ctrl.Call(m, "DescribeVolumesModificationsRequest", arg0) 12742 ret0, _ := ret[0].(*request.Request) 12743 ret1, _ := ret[1].(*ec2.DescribeVolumesModificationsOutput) 12744 return ret0, ret1 12745 } 12746 12747 // DescribeVolumesModificationsRequest indicates an expected call of DescribeVolumesModificationsRequest 12748 func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsRequest(arg0 interface{}) *gomock.Call { 12749 mr.mock.ctrl.T.Helper() 12750 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsRequest), arg0) 12751 } 12752 12753 // DescribeVolumesModificationsPages mocks base method 12754 func (m *MockEC2API) DescribeVolumesModificationsPages(arg0 *ec2.DescribeVolumesModificationsInput, arg1 func(*ec2.DescribeVolumesModificationsOutput, bool) bool) error { 12755 m.ctrl.T.Helper() 12756 ret := m.ctrl.Call(m, "DescribeVolumesModificationsPages", arg0, arg1) 12757 ret0, _ := ret[0].(error) 12758 return ret0 12759 } 12760 12761 // DescribeVolumesModificationsPages indicates an expected call of DescribeVolumesModificationsPages 12762 func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsPages(arg0, arg1 interface{}) *gomock.Call { 12763 mr.mock.ctrl.T.Helper() 12764 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsPages), arg0, arg1) 12765 } 12766 12767 // DescribeVolumesModificationsPagesWithContext mocks base method 12768 func (m *MockEC2API) DescribeVolumesModificationsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumesModificationsInput, arg2 func(*ec2.DescribeVolumesModificationsOutput, bool) bool, arg3 ...request.Option) error { 12769 m.ctrl.T.Helper() 12770 varargs := []interface{}{arg0, arg1, arg2} 12771 for _, a := range arg3 { 12772 varargs = append(varargs, a) 12773 } 12774 ret := m.ctrl.Call(m, "DescribeVolumesModificationsPagesWithContext", varargs...) 12775 ret0, _ := ret[0].(error) 12776 return ret0 12777 } 12778 12779 // DescribeVolumesModificationsPagesWithContext indicates an expected call of DescribeVolumesModificationsPagesWithContext 12780 func (mr *MockEC2APIMockRecorder) DescribeVolumesModificationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12781 mr.mock.ctrl.T.Helper() 12782 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12783 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVolumesModificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVolumesModificationsPagesWithContext), varargs...) 12784 } 12785 12786 // DescribeVpcAttribute mocks base method 12787 func (m *MockEC2API) DescribeVpcAttribute(arg0 *ec2.DescribeVpcAttributeInput) (*ec2.DescribeVpcAttributeOutput, error) { 12788 m.ctrl.T.Helper() 12789 ret := m.ctrl.Call(m, "DescribeVpcAttribute", arg0) 12790 ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput) 12791 ret1, _ := ret[1].(error) 12792 return ret0, ret1 12793 } 12794 12795 // DescribeVpcAttribute indicates an expected call of DescribeVpcAttribute 12796 func (mr *MockEC2APIMockRecorder) DescribeVpcAttribute(arg0 interface{}) *gomock.Call { 12797 mr.mock.ctrl.T.Helper() 12798 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttribute), arg0) 12799 } 12800 12801 // DescribeVpcAttributeWithContext mocks base method 12802 func (m *MockEC2API) DescribeVpcAttributeWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcAttributeInput, arg2 ...request.Option) (*ec2.DescribeVpcAttributeOutput, error) { 12803 m.ctrl.T.Helper() 12804 varargs := []interface{}{arg0, arg1} 12805 for _, a := range arg2 { 12806 varargs = append(varargs, a) 12807 } 12808 ret := m.ctrl.Call(m, "DescribeVpcAttributeWithContext", varargs...) 12809 ret0, _ := ret[0].(*ec2.DescribeVpcAttributeOutput) 12810 ret1, _ := ret[1].(error) 12811 return ret0, ret1 12812 } 12813 12814 // DescribeVpcAttributeWithContext indicates an expected call of DescribeVpcAttributeWithContext 12815 func (mr *MockEC2APIMockRecorder) DescribeVpcAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12816 mr.mock.ctrl.T.Helper() 12817 varargs := append([]interface{}{arg0, arg1}, arg2...) 12818 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttributeWithContext), varargs...) 12819 } 12820 12821 // DescribeVpcAttributeRequest mocks base method 12822 func (m *MockEC2API) DescribeVpcAttributeRequest(arg0 *ec2.DescribeVpcAttributeInput) (*request.Request, *ec2.DescribeVpcAttributeOutput) { 12823 m.ctrl.T.Helper() 12824 ret := m.ctrl.Call(m, "DescribeVpcAttributeRequest", arg0) 12825 ret0, _ := ret[0].(*request.Request) 12826 ret1, _ := ret[1].(*ec2.DescribeVpcAttributeOutput) 12827 return ret0, ret1 12828 } 12829 12830 // DescribeVpcAttributeRequest indicates an expected call of DescribeVpcAttributeRequest 12831 func (mr *MockEC2APIMockRecorder) DescribeVpcAttributeRequest(arg0 interface{}) *gomock.Call { 12832 mr.mock.ctrl.T.Helper() 12833 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcAttributeRequest), arg0) 12834 } 12835 12836 // DescribeVpcClassicLink mocks base method 12837 func (m *MockEC2API) DescribeVpcClassicLink(arg0 *ec2.DescribeVpcClassicLinkInput) (*ec2.DescribeVpcClassicLinkOutput, error) { 12838 m.ctrl.T.Helper() 12839 ret := m.ctrl.Call(m, "DescribeVpcClassicLink", arg0) 12840 ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput) 12841 ret1, _ := ret[1].(error) 12842 return ret0, ret1 12843 } 12844 12845 // DescribeVpcClassicLink indicates an expected call of DescribeVpcClassicLink 12846 func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLink(arg0 interface{}) *gomock.Call { 12847 mr.mock.ctrl.T.Helper() 12848 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLink), arg0) 12849 } 12850 12851 // DescribeVpcClassicLinkWithContext mocks base method 12852 func (m *MockEC2API) DescribeVpcClassicLinkWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkOutput, error) { 12853 m.ctrl.T.Helper() 12854 varargs := []interface{}{arg0, arg1} 12855 for _, a := range arg2 { 12856 varargs = append(varargs, a) 12857 } 12858 ret := m.ctrl.Call(m, "DescribeVpcClassicLinkWithContext", varargs...) 12859 ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkOutput) 12860 ret1, _ := ret[1].(error) 12861 return ret0, ret1 12862 } 12863 12864 // DescribeVpcClassicLinkWithContext indicates an expected call of DescribeVpcClassicLinkWithContext 12865 func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12866 mr.mock.ctrl.T.Helper() 12867 varargs := append([]interface{}{arg0, arg1}, arg2...) 12868 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkWithContext), varargs...) 12869 } 12870 12871 // DescribeVpcClassicLinkRequest mocks base method 12872 func (m *MockEC2API) DescribeVpcClassicLinkRequest(arg0 *ec2.DescribeVpcClassicLinkInput) (*request.Request, *ec2.DescribeVpcClassicLinkOutput) { 12873 m.ctrl.T.Helper() 12874 ret := m.ctrl.Call(m, "DescribeVpcClassicLinkRequest", arg0) 12875 ret0, _ := ret[0].(*request.Request) 12876 ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkOutput) 12877 return ret0, ret1 12878 } 12879 12880 // DescribeVpcClassicLinkRequest indicates an expected call of DescribeVpcClassicLinkRequest 12881 func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { 12882 mr.mock.ctrl.T.Helper() 12883 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkRequest), arg0) 12884 } 12885 12886 // DescribeVpcClassicLinkDnsSupport mocks base method 12887 func (m *MockEC2API) DescribeVpcClassicLinkDnsSupport(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) { 12888 m.ctrl.T.Helper() 12889 ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupport", arg0) 12890 ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) 12891 ret1, _ := ret[1].(error) 12892 return ret0, ret1 12893 } 12894 12895 // DescribeVpcClassicLinkDnsSupport indicates an expected call of DescribeVpcClassicLinkDnsSupport 12896 func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { 12897 mr.mock.ctrl.T.Helper() 12898 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupport), arg0) 12899 } 12900 12901 // DescribeVpcClassicLinkDnsSupportWithContext mocks base method 12902 func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DescribeVpcClassicLinkDnsSupportOutput, error) { 12903 m.ctrl.T.Helper() 12904 varargs := []interface{}{arg0, arg1} 12905 for _, a := range arg2 { 12906 varargs = append(varargs, a) 12907 } 12908 ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportWithContext", varargs...) 12909 ret0, _ := ret[0].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) 12910 ret1, _ := ret[1].(error) 12911 return ret0, ret1 12912 } 12913 12914 // DescribeVpcClassicLinkDnsSupportWithContext indicates an expected call of DescribeVpcClassicLinkDnsSupportWithContext 12915 func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12916 mr.mock.ctrl.T.Helper() 12917 varargs := append([]interface{}{arg0, arg1}, arg2...) 12918 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportWithContext), varargs...) 12919 } 12920 12921 // DescribeVpcClassicLinkDnsSupportRequest mocks base method 12922 func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportRequest(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DescribeVpcClassicLinkDnsSupportOutput) { 12923 m.ctrl.T.Helper() 12924 ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportRequest", arg0) 12925 ret0, _ := ret[0].(*request.Request) 12926 ret1, _ := ret[1].(*ec2.DescribeVpcClassicLinkDnsSupportOutput) 12927 return ret0, ret1 12928 } 12929 12930 // DescribeVpcClassicLinkDnsSupportRequest indicates an expected call of DescribeVpcClassicLinkDnsSupportRequest 12931 func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { 12932 mr.mock.ctrl.T.Helper() 12933 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportRequest), arg0) 12934 } 12935 12936 // DescribeVpcClassicLinkDnsSupportPages mocks base method 12937 func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPages(arg0 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg1 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool) error { 12938 m.ctrl.T.Helper() 12939 ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportPages", arg0, arg1) 12940 ret0, _ := ret[0].(error) 12941 return ret0 12942 } 12943 12944 // DescribeVpcClassicLinkDnsSupportPages indicates an expected call of DescribeVpcClassicLinkDnsSupportPages 12945 func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportPages(arg0, arg1 interface{}) *gomock.Call { 12946 mr.mock.ctrl.T.Helper() 12947 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPages), arg0, arg1) 12948 } 12949 12950 // DescribeVpcClassicLinkDnsSupportPagesWithContext mocks base method 12951 func (m *MockEC2API) DescribeVpcClassicLinkDnsSupportPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcClassicLinkDnsSupportInput, arg2 func(*ec2.DescribeVpcClassicLinkDnsSupportOutput, bool) bool, arg3 ...request.Option) error { 12952 m.ctrl.T.Helper() 12953 varargs := []interface{}{arg0, arg1, arg2} 12954 for _, a := range arg3 { 12955 varargs = append(varargs, a) 12956 } 12957 ret := m.ctrl.Call(m, "DescribeVpcClassicLinkDnsSupportPagesWithContext", varargs...) 12958 ret0, _ := ret[0].(error) 12959 return ret0 12960 } 12961 12962 // DescribeVpcClassicLinkDnsSupportPagesWithContext indicates an expected call of DescribeVpcClassicLinkDnsSupportPagesWithContext 12963 func (mr *MockEC2APIMockRecorder) DescribeVpcClassicLinkDnsSupportPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 12964 mr.mock.ctrl.T.Helper() 12965 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 12966 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcClassicLinkDnsSupportPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcClassicLinkDnsSupportPagesWithContext), varargs...) 12967 } 12968 12969 // DescribeVpcEndpointConnectionNotifications mocks base method 12970 func (m *MockEC2API) DescribeVpcEndpointConnectionNotifications(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) { 12971 m.ctrl.T.Helper() 12972 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotifications", arg0) 12973 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) 12974 ret1, _ := ret[1].(error) 12975 return ret0, ret1 12976 } 12977 12978 // DescribeVpcEndpointConnectionNotifications indicates an expected call of DescribeVpcEndpointConnectionNotifications 12979 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotifications(arg0 interface{}) *gomock.Call { 12980 mr.mock.ctrl.T.Helper() 12981 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotifications", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotifications), arg0) 12982 } 12983 12984 // DescribeVpcEndpointConnectionNotificationsWithContext mocks base method 12985 func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionNotificationsOutput, error) { 12986 m.ctrl.T.Helper() 12987 varargs := []interface{}{arg0, arg1} 12988 for _, a := range arg2 { 12989 varargs = append(varargs, a) 12990 } 12991 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsWithContext", varargs...) 12992 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) 12993 ret1, _ := ret[1].(error) 12994 return ret0, ret1 12995 } 12996 12997 // DescribeVpcEndpointConnectionNotificationsWithContext indicates an expected call of DescribeVpcEndpointConnectionNotificationsWithContext 12998 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 12999 mr.mock.ctrl.T.Helper() 13000 varargs := append([]interface{}{arg0, arg1}, arg2...) 13001 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsWithContext), varargs...) 13002 } 13003 13004 // DescribeVpcEndpointConnectionNotificationsRequest mocks base method 13005 func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsRequest(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionNotificationsOutput) { 13006 m.ctrl.T.Helper() 13007 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsRequest", arg0) 13008 ret0, _ := ret[0].(*request.Request) 13009 ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionNotificationsOutput) 13010 return ret0, ret1 13011 } 13012 13013 // DescribeVpcEndpointConnectionNotificationsRequest indicates an expected call of DescribeVpcEndpointConnectionNotificationsRequest 13014 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsRequest(arg0 interface{}) *gomock.Call { 13015 mr.mock.ctrl.T.Helper() 13016 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsRequest), arg0) 13017 } 13018 13019 // DescribeVpcEndpointConnectionNotificationsPages mocks base method 13020 func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPages(arg0 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool) error { 13021 m.ctrl.T.Helper() 13022 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsPages", arg0, arg1) 13023 ret0, _ := ret[0].(error) 13024 return ret0 13025 } 13026 13027 // DescribeVpcEndpointConnectionNotificationsPages indicates an expected call of DescribeVpcEndpointConnectionNotificationsPages 13028 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsPages(arg0, arg1 interface{}) *gomock.Call { 13029 mr.mock.ctrl.T.Helper() 13030 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPages), arg0, arg1) 13031 } 13032 13033 // DescribeVpcEndpointConnectionNotificationsPagesWithContext mocks base method 13034 func (m *MockEC2API) DescribeVpcEndpointConnectionNotificationsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointConnectionNotificationsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionNotificationsOutput, bool) bool, arg3 ...request.Option) error { 13035 m.ctrl.T.Helper() 13036 varargs := []interface{}{arg0, arg1, arg2} 13037 for _, a := range arg3 { 13038 varargs = append(varargs, a) 13039 } 13040 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", varargs...) 13041 ret0, _ := ret[0].(error) 13042 return ret0 13043 } 13044 13045 // DescribeVpcEndpointConnectionNotificationsPagesWithContext indicates an expected call of DescribeVpcEndpointConnectionNotificationsPagesWithContext 13046 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionNotificationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 13047 mr.mock.ctrl.T.Helper() 13048 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 13049 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionNotificationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionNotificationsPagesWithContext), varargs...) 13050 } 13051 13052 // DescribeVpcEndpointConnections mocks base method 13053 func (m *MockEC2API) DescribeVpcEndpointConnections(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*ec2.DescribeVpcEndpointConnectionsOutput, error) { 13054 m.ctrl.T.Helper() 13055 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnections", arg0) 13056 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput) 13057 ret1, _ := ret[1].(error) 13058 return ret0, ret1 13059 } 13060 13061 // DescribeVpcEndpointConnections indicates an expected call of DescribeVpcEndpointConnections 13062 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnections(arg0 interface{}) *gomock.Call { 13063 mr.mock.ctrl.T.Helper() 13064 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnections), arg0) 13065 } 13066 13067 // DescribeVpcEndpointConnectionsWithContext mocks base method 13068 func (m *MockEC2API) DescribeVpcEndpointConnectionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointConnectionsOutput, error) { 13069 m.ctrl.T.Helper() 13070 varargs := []interface{}{arg0, arg1} 13071 for _, a := range arg2 { 13072 varargs = append(varargs, a) 13073 } 13074 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsWithContext", varargs...) 13075 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointConnectionsOutput) 13076 ret1, _ := ret[1].(error) 13077 return ret0, ret1 13078 } 13079 13080 // DescribeVpcEndpointConnectionsWithContext indicates an expected call of DescribeVpcEndpointConnectionsWithContext 13081 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13082 mr.mock.ctrl.T.Helper() 13083 varargs := append([]interface{}{arg0, arg1}, arg2...) 13084 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsWithContext), varargs...) 13085 } 13086 13087 // DescribeVpcEndpointConnectionsRequest mocks base method 13088 func (m *MockEC2API) DescribeVpcEndpointConnectionsRequest(arg0 *ec2.DescribeVpcEndpointConnectionsInput) (*request.Request, *ec2.DescribeVpcEndpointConnectionsOutput) { 13089 m.ctrl.T.Helper() 13090 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsRequest", arg0) 13091 ret0, _ := ret[0].(*request.Request) 13092 ret1, _ := ret[1].(*ec2.DescribeVpcEndpointConnectionsOutput) 13093 return ret0, ret1 13094 } 13095 13096 // DescribeVpcEndpointConnectionsRequest indicates an expected call of DescribeVpcEndpointConnectionsRequest 13097 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { 13098 mr.mock.ctrl.T.Helper() 13099 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsRequest), arg0) 13100 } 13101 13102 // DescribeVpcEndpointConnectionsPages mocks base method 13103 func (m *MockEC2API) DescribeVpcEndpointConnectionsPages(arg0 *ec2.DescribeVpcEndpointConnectionsInput, arg1 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool) error { 13104 m.ctrl.T.Helper() 13105 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsPages", arg0, arg1) 13106 ret0, _ := ret[0].(error) 13107 return ret0 13108 } 13109 13110 // DescribeVpcEndpointConnectionsPages indicates an expected call of DescribeVpcEndpointConnectionsPages 13111 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsPages(arg0, arg1 interface{}) *gomock.Call { 13112 mr.mock.ctrl.T.Helper() 13113 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPages), arg0, arg1) 13114 } 13115 13116 // DescribeVpcEndpointConnectionsPagesWithContext mocks base method 13117 func (m *MockEC2API) DescribeVpcEndpointConnectionsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointConnectionsInput, arg2 func(*ec2.DescribeVpcEndpointConnectionsOutput, bool) bool, arg3 ...request.Option) error { 13118 m.ctrl.T.Helper() 13119 varargs := []interface{}{arg0, arg1, arg2} 13120 for _, a := range arg3 { 13121 varargs = append(varargs, a) 13122 } 13123 ret := m.ctrl.Call(m, "DescribeVpcEndpointConnectionsPagesWithContext", varargs...) 13124 ret0, _ := ret[0].(error) 13125 return ret0 13126 } 13127 13128 // DescribeVpcEndpointConnectionsPagesWithContext indicates an expected call of DescribeVpcEndpointConnectionsPagesWithContext 13129 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointConnectionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 13130 mr.mock.ctrl.T.Helper() 13131 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 13132 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointConnectionsPagesWithContext), varargs...) 13133 } 13134 13135 // DescribeVpcEndpointServiceConfigurations mocks base method 13136 func (m *MockEC2API) DescribeVpcEndpointServiceConfigurations(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) { 13137 m.ctrl.T.Helper() 13138 ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurations", arg0) 13139 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) 13140 ret1, _ := ret[1].(error) 13141 return ret0, ret1 13142 } 13143 13144 // DescribeVpcEndpointServiceConfigurations indicates an expected call of DescribeVpcEndpointServiceConfigurations 13145 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurations(arg0 interface{}) *gomock.Call { 13146 mr.mock.ctrl.T.Helper() 13147 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurations", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurations), arg0) 13148 } 13149 13150 // DescribeVpcEndpointServiceConfigurationsWithContext mocks base method 13151 func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServiceConfigurationsOutput, error) { 13152 m.ctrl.T.Helper() 13153 varargs := []interface{}{arg0, arg1} 13154 for _, a := range arg2 { 13155 varargs = append(varargs, a) 13156 } 13157 ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsWithContext", varargs...) 13158 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) 13159 ret1, _ := ret[1].(error) 13160 return ret0, ret1 13161 } 13162 13163 // DescribeVpcEndpointServiceConfigurationsWithContext indicates an expected call of DescribeVpcEndpointServiceConfigurationsWithContext 13164 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13165 mr.mock.ctrl.T.Helper() 13166 varargs := append([]interface{}{arg0, arg1}, arg2...) 13167 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsWithContext), varargs...) 13168 } 13169 13170 // DescribeVpcEndpointServiceConfigurationsRequest mocks base method 13171 func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsRequest(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput) (*request.Request, *ec2.DescribeVpcEndpointServiceConfigurationsOutput) { 13172 m.ctrl.T.Helper() 13173 ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsRequest", arg0) 13174 ret0, _ := ret[0].(*request.Request) 13175 ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServiceConfigurationsOutput) 13176 return ret0, ret1 13177 } 13178 13179 // DescribeVpcEndpointServiceConfigurationsRequest indicates an expected call of DescribeVpcEndpointServiceConfigurationsRequest 13180 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsRequest(arg0 interface{}) *gomock.Call { 13181 mr.mock.ctrl.T.Helper() 13182 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsRequest), arg0) 13183 } 13184 13185 // DescribeVpcEndpointServiceConfigurationsPages mocks base method 13186 func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPages(arg0 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg1 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool) error { 13187 m.ctrl.T.Helper() 13188 ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsPages", arg0, arg1) 13189 ret0, _ := ret[0].(error) 13190 return ret0 13191 } 13192 13193 // DescribeVpcEndpointServiceConfigurationsPages indicates an expected call of DescribeVpcEndpointServiceConfigurationsPages 13194 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsPages(arg0, arg1 interface{}) *gomock.Call { 13195 mr.mock.ctrl.T.Helper() 13196 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPages), arg0, arg1) 13197 } 13198 13199 // DescribeVpcEndpointServiceConfigurationsPagesWithContext mocks base method 13200 func (m *MockEC2API) DescribeVpcEndpointServiceConfigurationsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointServiceConfigurationsInput, arg2 func(*ec2.DescribeVpcEndpointServiceConfigurationsOutput, bool) bool, arg3 ...request.Option) error { 13201 m.ctrl.T.Helper() 13202 varargs := []interface{}{arg0, arg1, arg2} 13203 for _, a := range arg3 { 13204 varargs = append(varargs, a) 13205 } 13206 ret := m.ctrl.Call(m, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", varargs...) 13207 ret0, _ := ret[0].(error) 13208 return ret0 13209 } 13210 13211 // DescribeVpcEndpointServiceConfigurationsPagesWithContext indicates an expected call of DescribeVpcEndpointServiceConfigurationsPagesWithContext 13212 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServiceConfigurationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 13213 mr.mock.ctrl.T.Helper() 13214 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 13215 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServiceConfigurationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServiceConfigurationsPagesWithContext), varargs...) 13216 } 13217 13218 // DescribeVpcEndpointServicePermissions mocks base method 13219 func (m *MockEC2API) DescribeVpcEndpointServicePermissions(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) { 13220 m.ctrl.T.Helper() 13221 ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissions", arg0) 13222 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput) 13223 ret1, _ := ret[1].(error) 13224 return ret0, ret1 13225 } 13226 13227 // DescribeVpcEndpointServicePermissions indicates an expected call of DescribeVpcEndpointServicePermissions 13228 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call { 13229 mr.mock.ctrl.T.Helper() 13230 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissions), arg0) 13231 } 13232 13233 // DescribeVpcEndpointServicePermissionsWithContext mocks base method 13234 func (m *MockEC2API) DescribeVpcEndpointServicePermissionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicePermissionsOutput, error) { 13235 m.ctrl.T.Helper() 13236 varargs := []interface{}{arg0, arg1} 13237 for _, a := range arg2 { 13238 varargs = append(varargs, a) 13239 } 13240 ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsWithContext", varargs...) 13241 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicePermissionsOutput) 13242 ret1, _ := ret[1].(error) 13243 return ret0, ret1 13244 } 13245 13246 // DescribeVpcEndpointServicePermissionsWithContext indicates an expected call of DescribeVpcEndpointServicePermissionsWithContext 13247 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13248 mr.mock.ctrl.T.Helper() 13249 varargs := append([]interface{}{arg0, arg1}, arg2...) 13250 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsWithContext), varargs...) 13251 } 13252 13253 // DescribeVpcEndpointServicePermissionsRequest mocks base method 13254 func (m *MockEC2API) DescribeVpcEndpointServicePermissionsRequest(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput) (*request.Request, *ec2.DescribeVpcEndpointServicePermissionsOutput) { 13255 m.ctrl.T.Helper() 13256 ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsRequest", arg0) 13257 ret0, _ := ret[0].(*request.Request) 13258 ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicePermissionsOutput) 13259 return ret0, ret1 13260 } 13261 13262 // DescribeVpcEndpointServicePermissionsRequest indicates an expected call of DescribeVpcEndpointServicePermissionsRequest 13263 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call { 13264 mr.mock.ctrl.T.Helper() 13265 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsRequest), arg0) 13266 } 13267 13268 // DescribeVpcEndpointServicePermissionsPages mocks base method 13269 func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPages(arg0 *ec2.DescribeVpcEndpointServicePermissionsInput, arg1 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool) error { 13270 m.ctrl.T.Helper() 13271 ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsPages", arg0, arg1) 13272 ret0, _ := ret[0].(error) 13273 return ret0 13274 } 13275 13276 // DescribeVpcEndpointServicePermissionsPages indicates an expected call of DescribeVpcEndpointServicePermissionsPages 13277 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsPages(arg0, arg1 interface{}) *gomock.Call { 13278 mr.mock.ctrl.T.Helper() 13279 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPages), arg0, arg1) 13280 } 13281 13282 // DescribeVpcEndpointServicePermissionsPagesWithContext mocks base method 13283 func (m *MockEC2API) DescribeVpcEndpointServicePermissionsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointServicePermissionsInput, arg2 func(*ec2.DescribeVpcEndpointServicePermissionsOutput, bool) bool, arg3 ...request.Option) error { 13284 m.ctrl.T.Helper() 13285 varargs := []interface{}{arg0, arg1, arg2} 13286 for _, a := range arg3 { 13287 varargs = append(varargs, a) 13288 } 13289 ret := m.ctrl.Call(m, "DescribeVpcEndpointServicePermissionsPagesWithContext", varargs...) 13290 ret0, _ := ret[0].(error) 13291 return ret0 13292 } 13293 13294 // DescribeVpcEndpointServicePermissionsPagesWithContext indicates an expected call of DescribeVpcEndpointServicePermissionsPagesWithContext 13295 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicePermissionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 13296 mr.mock.ctrl.T.Helper() 13297 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 13298 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicePermissionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicePermissionsPagesWithContext), varargs...) 13299 } 13300 13301 // DescribeVpcEndpointServices mocks base method 13302 func (m *MockEC2API) DescribeVpcEndpointServices(arg0 *ec2.DescribeVpcEndpointServicesInput) (*ec2.DescribeVpcEndpointServicesOutput, error) { 13303 m.ctrl.T.Helper() 13304 ret := m.ctrl.Call(m, "DescribeVpcEndpointServices", arg0) 13305 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput) 13306 ret1, _ := ret[1].(error) 13307 return ret0, ret1 13308 } 13309 13310 // DescribeVpcEndpointServices indicates an expected call of DescribeVpcEndpointServices 13311 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServices(arg0 interface{}) *gomock.Call { 13312 mr.mock.ctrl.T.Helper() 13313 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServices", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServices), arg0) 13314 } 13315 13316 // DescribeVpcEndpointServicesWithContext mocks base method 13317 func (m *MockEC2API) DescribeVpcEndpointServicesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointServicesInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointServicesOutput, error) { 13318 m.ctrl.T.Helper() 13319 varargs := []interface{}{arg0, arg1} 13320 for _, a := range arg2 { 13321 varargs = append(varargs, a) 13322 } 13323 ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesWithContext", varargs...) 13324 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointServicesOutput) 13325 ret1, _ := ret[1].(error) 13326 return ret0, ret1 13327 } 13328 13329 // DescribeVpcEndpointServicesWithContext indicates an expected call of DescribeVpcEndpointServicesWithContext 13330 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13331 mr.mock.ctrl.T.Helper() 13332 varargs := append([]interface{}{arg0, arg1}, arg2...) 13333 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicesWithContext), varargs...) 13334 } 13335 13336 // DescribeVpcEndpointServicesRequest mocks base method 13337 func (m *MockEC2API) DescribeVpcEndpointServicesRequest(arg0 *ec2.DescribeVpcEndpointServicesInput) (*request.Request, *ec2.DescribeVpcEndpointServicesOutput) { 13338 m.ctrl.T.Helper() 13339 ret := m.ctrl.Call(m, "DescribeVpcEndpointServicesRequest", arg0) 13340 ret0, _ := ret[0].(*request.Request) 13341 ret1, _ := ret[1].(*ec2.DescribeVpcEndpointServicesOutput) 13342 return ret0, ret1 13343 } 13344 13345 // DescribeVpcEndpointServicesRequest indicates an expected call of DescribeVpcEndpointServicesRequest 13346 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointServicesRequest(arg0 interface{}) *gomock.Call { 13347 mr.mock.ctrl.T.Helper() 13348 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointServicesRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointServicesRequest), arg0) 13349 } 13350 13351 // DescribeVpcEndpoints mocks base method 13352 func (m *MockEC2API) DescribeVpcEndpoints(arg0 *ec2.DescribeVpcEndpointsInput) (*ec2.DescribeVpcEndpointsOutput, error) { 13353 m.ctrl.T.Helper() 13354 ret := m.ctrl.Call(m, "DescribeVpcEndpoints", arg0) 13355 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput) 13356 ret1, _ := ret[1].(error) 13357 return ret0, ret1 13358 } 13359 13360 // DescribeVpcEndpoints indicates an expected call of DescribeVpcEndpoints 13361 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpoints(arg0 interface{}) *gomock.Call { 13362 mr.mock.ctrl.T.Helper() 13363 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpoints", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpoints), arg0) 13364 } 13365 13366 // DescribeVpcEndpointsWithContext mocks base method 13367 func (m *MockEC2API) DescribeVpcEndpointsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 ...request.Option) (*ec2.DescribeVpcEndpointsOutput, error) { 13368 m.ctrl.T.Helper() 13369 varargs := []interface{}{arg0, arg1} 13370 for _, a := range arg2 { 13371 varargs = append(varargs, a) 13372 } 13373 ret := m.ctrl.Call(m, "DescribeVpcEndpointsWithContext", varargs...) 13374 ret0, _ := ret[0].(*ec2.DescribeVpcEndpointsOutput) 13375 ret1, _ := ret[1].(error) 13376 return ret0, ret1 13377 } 13378 13379 // DescribeVpcEndpointsWithContext indicates an expected call of DescribeVpcEndpointsWithContext 13380 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13381 mr.mock.ctrl.T.Helper() 13382 varargs := append([]interface{}{arg0, arg1}, arg2...) 13383 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsWithContext), varargs...) 13384 } 13385 13386 // DescribeVpcEndpointsRequest mocks base method 13387 func (m *MockEC2API) DescribeVpcEndpointsRequest(arg0 *ec2.DescribeVpcEndpointsInput) (*request.Request, *ec2.DescribeVpcEndpointsOutput) { 13388 m.ctrl.T.Helper() 13389 ret := m.ctrl.Call(m, "DescribeVpcEndpointsRequest", arg0) 13390 ret0, _ := ret[0].(*request.Request) 13391 ret1, _ := ret[1].(*ec2.DescribeVpcEndpointsOutput) 13392 return ret0, ret1 13393 } 13394 13395 // DescribeVpcEndpointsRequest indicates an expected call of DescribeVpcEndpointsRequest 13396 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsRequest(arg0 interface{}) *gomock.Call { 13397 mr.mock.ctrl.T.Helper() 13398 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsRequest), arg0) 13399 } 13400 13401 // DescribeVpcEndpointsPages mocks base method 13402 func (m *MockEC2API) DescribeVpcEndpointsPages(arg0 *ec2.DescribeVpcEndpointsInput, arg1 func(*ec2.DescribeVpcEndpointsOutput, bool) bool) error { 13403 m.ctrl.T.Helper() 13404 ret := m.ctrl.Call(m, "DescribeVpcEndpointsPages", arg0, arg1) 13405 ret0, _ := ret[0].(error) 13406 return ret0 13407 } 13408 13409 // DescribeVpcEndpointsPages indicates an expected call of DescribeVpcEndpointsPages 13410 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsPages(arg0, arg1 interface{}) *gomock.Call { 13411 mr.mock.ctrl.T.Helper() 13412 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPages), arg0, arg1) 13413 } 13414 13415 // DescribeVpcEndpointsPagesWithContext mocks base method 13416 func (m *MockEC2API) DescribeVpcEndpointsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcEndpointsInput, arg2 func(*ec2.DescribeVpcEndpointsOutput, bool) bool, arg3 ...request.Option) error { 13417 m.ctrl.T.Helper() 13418 varargs := []interface{}{arg0, arg1, arg2} 13419 for _, a := range arg3 { 13420 varargs = append(varargs, a) 13421 } 13422 ret := m.ctrl.Call(m, "DescribeVpcEndpointsPagesWithContext", varargs...) 13423 ret0, _ := ret[0].(error) 13424 return ret0 13425 } 13426 13427 // DescribeVpcEndpointsPagesWithContext indicates an expected call of DescribeVpcEndpointsPagesWithContext 13428 func (mr *MockEC2APIMockRecorder) DescribeVpcEndpointsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 13429 mr.mock.ctrl.T.Helper() 13430 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 13431 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcEndpointsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcEndpointsPagesWithContext), varargs...) 13432 } 13433 13434 // DescribeVpcPeeringConnections mocks base method 13435 func (m *MockEC2API) DescribeVpcPeeringConnections(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*ec2.DescribeVpcPeeringConnectionsOutput, error) { 13436 m.ctrl.T.Helper() 13437 ret := m.ctrl.Call(m, "DescribeVpcPeeringConnections", arg0) 13438 ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput) 13439 ret1, _ := ret[1].(error) 13440 return ret0, ret1 13441 } 13442 13443 // DescribeVpcPeeringConnections indicates an expected call of DescribeVpcPeeringConnections 13444 func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnections(arg0 interface{}) *gomock.Call { 13445 mr.mock.ctrl.T.Helper() 13446 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnections), arg0) 13447 } 13448 13449 // DescribeVpcPeeringConnectionsWithContext mocks base method 13450 func (m *MockEC2API) DescribeVpcPeeringConnectionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpcPeeringConnectionsOutput, error) { 13451 m.ctrl.T.Helper() 13452 varargs := []interface{}{arg0, arg1} 13453 for _, a := range arg2 { 13454 varargs = append(varargs, a) 13455 } 13456 ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsWithContext", varargs...) 13457 ret0, _ := ret[0].(*ec2.DescribeVpcPeeringConnectionsOutput) 13458 ret1, _ := ret[1].(error) 13459 return ret0, ret1 13460 } 13461 13462 // DescribeVpcPeeringConnectionsWithContext indicates an expected call of DescribeVpcPeeringConnectionsWithContext 13463 func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13464 mr.mock.ctrl.T.Helper() 13465 varargs := append([]interface{}{arg0, arg1}, arg2...) 13466 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsWithContext), varargs...) 13467 } 13468 13469 // DescribeVpcPeeringConnectionsRequest mocks base method 13470 func (m *MockEC2API) DescribeVpcPeeringConnectionsRequest(arg0 *ec2.DescribeVpcPeeringConnectionsInput) (*request.Request, *ec2.DescribeVpcPeeringConnectionsOutput) { 13471 m.ctrl.T.Helper() 13472 ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsRequest", arg0) 13473 ret0, _ := ret[0].(*request.Request) 13474 ret1, _ := ret[1].(*ec2.DescribeVpcPeeringConnectionsOutput) 13475 return ret0, ret1 13476 } 13477 13478 // DescribeVpcPeeringConnectionsRequest indicates an expected call of DescribeVpcPeeringConnectionsRequest 13479 func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsRequest(arg0 interface{}) *gomock.Call { 13480 mr.mock.ctrl.T.Helper() 13481 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsRequest), arg0) 13482 } 13483 13484 // DescribeVpcPeeringConnectionsPages mocks base method 13485 func (m *MockEC2API) DescribeVpcPeeringConnectionsPages(arg0 *ec2.DescribeVpcPeeringConnectionsInput, arg1 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool) error { 13486 m.ctrl.T.Helper() 13487 ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsPages", arg0, arg1) 13488 ret0, _ := ret[0].(error) 13489 return ret0 13490 } 13491 13492 // DescribeVpcPeeringConnectionsPages indicates an expected call of DescribeVpcPeeringConnectionsPages 13493 func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsPages(arg0, arg1 interface{}) *gomock.Call { 13494 mr.mock.ctrl.T.Helper() 13495 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPages), arg0, arg1) 13496 } 13497 13498 // DescribeVpcPeeringConnectionsPagesWithContext mocks base method 13499 func (m *MockEC2API) DescribeVpcPeeringConnectionsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 func(*ec2.DescribeVpcPeeringConnectionsOutput, bool) bool, arg3 ...request.Option) error { 13500 m.ctrl.T.Helper() 13501 varargs := []interface{}{arg0, arg1, arg2} 13502 for _, a := range arg3 { 13503 varargs = append(varargs, a) 13504 } 13505 ret := m.ctrl.Call(m, "DescribeVpcPeeringConnectionsPagesWithContext", varargs...) 13506 ret0, _ := ret[0].(error) 13507 return ret0 13508 } 13509 13510 // DescribeVpcPeeringConnectionsPagesWithContext indicates an expected call of DescribeVpcPeeringConnectionsPagesWithContext 13511 func (mr *MockEC2APIMockRecorder) DescribeVpcPeeringConnectionsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 13512 mr.mock.ctrl.T.Helper() 13513 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 13514 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcPeeringConnectionsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcPeeringConnectionsPagesWithContext), varargs...) 13515 } 13516 13517 // DescribeVpcs mocks base method 13518 func (m *MockEC2API) DescribeVpcs(arg0 *ec2.DescribeVpcsInput) (*ec2.DescribeVpcsOutput, error) { 13519 m.ctrl.T.Helper() 13520 ret := m.ctrl.Call(m, "DescribeVpcs", arg0) 13521 ret0, _ := ret[0].(*ec2.DescribeVpcsOutput) 13522 ret1, _ := ret[1].(error) 13523 return ret0, ret1 13524 } 13525 13526 // DescribeVpcs indicates an expected call of DescribeVpcs 13527 func (mr *MockEC2APIMockRecorder) DescribeVpcs(arg0 interface{}) *gomock.Call { 13528 mr.mock.ctrl.T.Helper() 13529 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcs", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcs), arg0) 13530 } 13531 13532 // DescribeVpcsWithContext mocks base method 13533 func (m *MockEC2API) DescribeVpcsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.Option) (*ec2.DescribeVpcsOutput, error) { 13534 m.ctrl.T.Helper() 13535 varargs := []interface{}{arg0, arg1} 13536 for _, a := range arg2 { 13537 varargs = append(varargs, a) 13538 } 13539 ret := m.ctrl.Call(m, "DescribeVpcsWithContext", varargs...) 13540 ret0, _ := ret[0].(*ec2.DescribeVpcsOutput) 13541 ret1, _ := ret[1].(error) 13542 return ret0, ret1 13543 } 13544 13545 // DescribeVpcsWithContext indicates an expected call of DescribeVpcsWithContext 13546 func (mr *MockEC2APIMockRecorder) DescribeVpcsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13547 mr.mock.ctrl.T.Helper() 13548 varargs := append([]interface{}{arg0, arg1}, arg2...) 13549 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsWithContext), varargs...) 13550 } 13551 13552 // DescribeVpcsRequest mocks base method 13553 func (m *MockEC2API) DescribeVpcsRequest(arg0 *ec2.DescribeVpcsInput) (*request.Request, *ec2.DescribeVpcsOutput) { 13554 m.ctrl.T.Helper() 13555 ret := m.ctrl.Call(m, "DescribeVpcsRequest", arg0) 13556 ret0, _ := ret[0].(*request.Request) 13557 ret1, _ := ret[1].(*ec2.DescribeVpcsOutput) 13558 return ret0, ret1 13559 } 13560 13561 // DescribeVpcsRequest indicates an expected call of DescribeVpcsRequest 13562 func (mr *MockEC2APIMockRecorder) DescribeVpcsRequest(arg0 interface{}) *gomock.Call { 13563 mr.mock.ctrl.T.Helper() 13564 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsRequest), arg0) 13565 } 13566 13567 // DescribeVpcsPages mocks base method 13568 func (m *MockEC2API) DescribeVpcsPages(arg0 *ec2.DescribeVpcsInput, arg1 func(*ec2.DescribeVpcsOutput, bool) bool) error { 13569 m.ctrl.T.Helper() 13570 ret := m.ctrl.Call(m, "DescribeVpcsPages", arg0, arg1) 13571 ret0, _ := ret[0].(error) 13572 return ret0 13573 } 13574 13575 // DescribeVpcsPages indicates an expected call of DescribeVpcsPages 13576 func (mr *MockEC2APIMockRecorder) DescribeVpcsPages(arg0, arg1 interface{}) *gomock.Call { 13577 mr.mock.ctrl.T.Helper() 13578 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsPages", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsPages), arg0, arg1) 13579 } 13580 13581 // DescribeVpcsPagesWithContext mocks base method 13582 func (m *MockEC2API) DescribeVpcsPagesWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcsInput, arg2 func(*ec2.DescribeVpcsOutput, bool) bool, arg3 ...request.Option) error { 13583 m.ctrl.T.Helper() 13584 varargs := []interface{}{arg0, arg1, arg2} 13585 for _, a := range arg3 { 13586 varargs = append(varargs, a) 13587 } 13588 ret := m.ctrl.Call(m, "DescribeVpcsPagesWithContext", varargs...) 13589 ret0, _ := ret[0].(error) 13590 return ret0 13591 } 13592 13593 // DescribeVpcsPagesWithContext indicates an expected call of DescribeVpcsPagesWithContext 13594 func (mr *MockEC2APIMockRecorder) DescribeVpcsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 13595 mr.mock.ctrl.T.Helper() 13596 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 13597 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpcsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpcsPagesWithContext), varargs...) 13598 } 13599 13600 // DescribeVpnConnections mocks base method 13601 func (m *MockEC2API) DescribeVpnConnections(arg0 *ec2.DescribeVpnConnectionsInput) (*ec2.DescribeVpnConnectionsOutput, error) { 13602 m.ctrl.T.Helper() 13603 ret := m.ctrl.Call(m, "DescribeVpnConnections", arg0) 13604 ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput) 13605 ret1, _ := ret[1].(error) 13606 return ret0, ret1 13607 } 13608 13609 // DescribeVpnConnections indicates an expected call of DescribeVpnConnections 13610 func (mr *MockEC2APIMockRecorder) DescribeVpnConnections(arg0 interface{}) *gomock.Call { 13611 mr.mock.ctrl.T.Helper() 13612 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnections", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnections), arg0) 13613 } 13614 13615 // DescribeVpnConnectionsWithContext mocks base method 13616 func (m *MockEC2API) DescribeVpnConnectionsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.Option) (*ec2.DescribeVpnConnectionsOutput, error) { 13617 m.ctrl.T.Helper() 13618 varargs := []interface{}{arg0, arg1} 13619 for _, a := range arg2 { 13620 varargs = append(varargs, a) 13621 } 13622 ret := m.ctrl.Call(m, "DescribeVpnConnectionsWithContext", varargs...) 13623 ret0, _ := ret[0].(*ec2.DescribeVpnConnectionsOutput) 13624 ret1, _ := ret[1].(error) 13625 return ret0, ret1 13626 } 13627 13628 // DescribeVpnConnectionsWithContext indicates an expected call of DescribeVpnConnectionsWithContext 13629 func (mr *MockEC2APIMockRecorder) DescribeVpnConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13630 mr.mock.ctrl.T.Helper() 13631 varargs := append([]interface{}{arg0, arg1}, arg2...) 13632 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnectionsWithContext), varargs...) 13633 } 13634 13635 // DescribeVpnConnectionsRequest mocks base method 13636 func (m *MockEC2API) DescribeVpnConnectionsRequest(arg0 *ec2.DescribeVpnConnectionsInput) (*request.Request, *ec2.DescribeVpnConnectionsOutput) { 13637 m.ctrl.T.Helper() 13638 ret := m.ctrl.Call(m, "DescribeVpnConnectionsRequest", arg0) 13639 ret0, _ := ret[0].(*request.Request) 13640 ret1, _ := ret[1].(*ec2.DescribeVpnConnectionsOutput) 13641 return ret0, ret1 13642 } 13643 13644 // DescribeVpnConnectionsRequest indicates an expected call of DescribeVpnConnectionsRequest 13645 func (mr *MockEC2APIMockRecorder) DescribeVpnConnectionsRequest(arg0 interface{}) *gomock.Call { 13646 mr.mock.ctrl.T.Helper() 13647 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnConnectionsRequest), arg0) 13648 } 13649 13650 // DescribeVpnGateways mocks base method 13651 func (m *MockEC2API) DescribeVpnGateways(arg0 *ec2.DescribeVpnGatewaysInput) (*ec2.DescribeVpnGatewaysOutput, error) { 13652 m.ctrl.T.Helper() 13653 ret := m.ctrl.Call(m, "DescribeVpnGateways", arg0) 13654 ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput) 13655 ret1, _ := ret[1].(error) 13656 return ret0, ret1 13657 } 13658 13659 // DescribeVpnGateways indicates an expected call of DescribeVpnGateways 13660 func (mr *MockEC2APIMockRecorder) DescribeVpnGateways(arg0 interface{}) *gomock.Call { 13661 mr.mock.ctrl.T.Helper() 13662 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGateways", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGateways), arg0) 13663 } 13664 13665 // DescribeVpnGatewaysWithContext mocks base method 13666 func (m *MockEC2API) DescribeVpnGatewaysWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpnGatewaysInput, arg2 ...request.Option) (*ec2.DescribeVpnGatewaysOutput, error) { 13667 m.ctrl.T.Helper() 13668 varargs := []interface{}{arg0, arg1} 13669 for _, a := range arg2 { 13670 varargs = append(varargs, a) 13671 } 13672 ret := m.ctrl.Call(m, "DescribeVpnGatewaysWithContext", varargs...) 13673 ret0, _ := ret[0].(*ec2.DescribeVpnGatewaysOutput) 13674 ret1, _ := ret[1].(error) 13675 return ret0, ret1 13676 } 13677 13678 // DescribeVpnGatewaysWithContext indicates an expected call of DescribeVpnGatewaysWithContext 13679 func (mr *MockEC2APIMockRecorder) DescribeVpnGatewaysWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13680 mr.mock.ctrl.T.Helper() 13681 varargs := append([]interface{}{arg0, arg1}, arg2...) 13682 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGatewaysWithContext", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGatewaysWithContext), varargs...) 13683 } 13684 13685 // DescribeVpnGatewaysRequest mocks base method 13686 func (m *MockEC2API) DescribeVpnGatewaysRequest(arg0 *ec2.DescribeVpnGatewaysInput) (*request.Request, *ec2.DescribeVpnGatewaysOutput) { 13687 m.ctrl.T.Helper() 13688 ret := m.ctrl.Call(m, "DescribeVpnGatewaysRequest", arg0) 13689 ret0, _ := ret[0].(*request.Request) 13690 ret1, _ := ret[1].(*ec2.DescribeVpnGatewaysOutput) 13691 return ret0, ret1 13692 } 13693 13694 // DescribeVpnGatewaysRequest indicates an expected call of DescribeVpnGatewaysRequest 13695 func (mr *MockEC2APIMockRecorder) DescribeVpnGatewaysRequest(arg0 interface{}) *gomock.Call { 13696 mr.mock.ctrl.T.Helper() 13697 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DescribeVpnGatewaysRequest", reflect.TypeOf((*MockEC2API)(nil).DescribeVpnGatewaysRequest), arg0) 13698 } 13699 13700 // DetachClassicLinkVpc mocks base method 13701 func (m *MockEC2API) DetachClassicLinkVpc(arg0 *ec2.DetachClassicLinkVpcInput) (*ec2.DetachClassicLinkVpcOutput, error) { 13702 m.ctrl.T.Helper() 13703 ret := m.ctrl.Call(m, "DetachClassicLinkVpc", arg0) 13704 ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput) 13705 ret1, _ := ret[1].(error) 13706 return ret0, ret1 13707 } 13708 13709 // DetachClassicLinkVpc indicates an expected call of DetachClassicLinkVpc 13710 func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpc(arg0 interface{}) *gomock.Call { 13711 mr.mock.ctrl.T.Helper() 13712 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpc", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpc), arg0) 13713 } 13714 13715 // DetachClassicLinkVpcWithContext mocks base method 13716 func (m *MockEC2API) DetachClassicLinkVpcWithContext(arg0 aws.Context, arg1 *ec2.DetachClassicLinkVpcInput, arg2 ...request.Option) (*ec2.DetachClassicLinkVpcOutput, error) { 13717 m.ctrl.T.Helper() 13718 varargs := []interface{}{arg0, arg1} 13719 for _, a := range arg2 { 13720 varargs = append(varargs, a) 13721 } 13722 ret := m.ctrl.Call(m, "DetachClassicLinkVpcWithContext", varargs...) 13723 ret0, _ := ret[0].(*ec2.DetachClassicLinkVpcOutput) 13724 ret1, _ := ret[1].(error) 13725 return ret0, ret1 13726 } 13727 13728 // DetachClassicLinkVpcWithContext indicates an expected call of DetachClassicLinkVpcWithContext 13729 func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13730 mr.mock.ctrl.T.Helper() 13731 varargs := append([]interface{}{arg0, arg1}, arg2...) 13732 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpcWithContext), varargs...) 13733 } 13734 13735 // DetachClassicLinkVpcRequest mocks base method 13736 func (m *MockEC2API) DetachClassicLinkVpcRequest(arg0 *ec2.DetachClassicLinkVpcInput) (*request.Request, *ec2.DetachClassicLinkVpcOutput) { 13737 m.ctrl.T.Helper() 13738 ret := m.ctrl.Call(m, "DetachClassicLinkVpcRequest", arg0) 13739 ret0, _ := ret[0].(*request.Request) 13740 ret1, _ := ret[1].(*ec2.DetachClassicLinkVpcOutput) 13741 return ret0, ret1 13742 } 13743 13744 // DetachClassicLinkVpcRequest indicates an expected call of DetachClassicLinkVpcRequest 13745 func (mr *MockEC2APIMockRecorder) DetachClassicLinkVpcRequest(arg0 interface{}) *gomock.Call { 13746 mr.mock.ctrl.T.Helper() 13747 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachClassicLinkVpcRequest", reflect.TypeOf((*MockEC2API)(nil).DetachClassicLinkVpcRequest), arg0) 13748 } 13749 13750 // DetachInternetGateway mocks base method 13751 func (m *MockEC2API) DetachInternetGateway(arg0 *ec2.DetachInternetGatewayInput) (*ec2.DetachInternetGatewayOutput, error) { 13752 m.ctrl.T.Helper() 13753 ret := m.ctrl.Call(m, "DetachInternetGateway", arg0) 13754 ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput) 13755 ret1, _ := ret[1].(error) 13756 return ret0, ret1 13757 } 13758 13759 // DetachInternetGateway indicates an expected call of DetachInternetGateway 13760 func (mr *MockEC2APIMockRecorder) DetachInternetGateway(arg0 interface{}) *gomock.Call { 13761 mr.mock.ctrl.T.Helper() 13762 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGateway", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGateway), arg0) 13763 } 13764 13765 // DetachInternetGatewayWithContext mocks base method 13766 func (m *MockEC2API) DetachInternetGatewayWithContext(arg0 aws.Context, arg1 *ec2.DetachInternetGatewayInput, arg2 ...request.Option) (*ec2.DetachInternetGatewayOutput, error) { 13767 m.ctrl.T.Helper() 13768 varargs := []interface{}{arg0, arg1} 13769 for _, a := range arg2 { 13770 varargs = append(varargs, a) 13771 } 13772 ret := m.ctrl.Call(m, "DetachInternetGatewayWithContext", varargs...) 13773 ret0, _ := ret[0].(*ec2.DetachInternetGatewayOutput) 13774 ret1, _ := ret[1].(error) 13775 return ret0, ret1 13776 } 13777 13778 // DetachInternetGatewayWithContext indicates an expected call of DetachInternetGatewayWithContext 13779 func (mr *MockEC2APIMockRecorder) DetachInternetGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13780 mr.mock.ctrl.T.Helper() 13781 varargs := append([]interface{}{arg0, arg1}, arg2...) 13782 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGatewayWithContext), varargs...) 13783 } 13784 13785 // DetachInternetGatewayRequest mocks base method 13786 func (m *MockEC2API) DetachInternetGatewayRequest(arg0 *ec2.DetachInternetGatewayInput) (*request.Request, *ec2.DetachInternetGatewayOutput) { 13787 m.ctrl.T.Helper() 13788 ret := m.ctrl.Call(m, "DetachInternetGatewayRequest", arg0) 13789 ret0, _ := ret[0].(*request.Request) 13790 ret1, _ := ret[1].(*ec2.DetachInternetGatewayOutput) 13791 return ret0, ret1 13792 } 13793 13794 // DetachInternetGatewayRequest indicates an expected call of DetachInternetGatewayRequest 13795 func (mr *MockEC2APIMockRecorder) DetachInternetGatewayRequest(arg0 interface{}) *gomock.Call { 13796 mr.mock.ctrl.T.Helper() 13797 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachInternetGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachInternetGatewayRequest), arg0) 13798 } 13799 13800 // DetachNetworkInterface mocks base method 13801 func (m *MockEC2API) DetachNetworkInterface(arg0 *ec2.DetachNetworkInterfaceInput) (*ec2.DetachNetworkInterfaceOutput, error) { 13802 m.ctrl.T.Helper() 13803 ret := m.ctrl.Call(m, "DetachNetworkInterface", arg0) 13804 ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput) 13805 ret1, _ := ret[1].(error) 13806 return ret0, ret1 13807 } 13808 13809 // DetachNetworkInterface indicates an expected call of DetachNetworkInterface 13810 func (mr *MockEC2APIMockRecorder) DetachNetworkInterface(arg0 interface{}) *gomock.Call { 13811 mr.mock.ctrl.T.Helper() 13812 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterface", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterface), arg0) 13813 } 13814 13815 // DetachNetworkInterfaceWithContext mocks base method 13816 func (m *MockEC2API) DetachNetworkInterfaceWithContext(arg0 aws.Context, arg1 *ec2.DetachNetworkInterfaceInput, arg2 ...request.Option) (*ec2.DetachNetworkInterfaceOutput, error) { 13817 m.ctrl.T.Helper() 13818 varargs := []interface{}{arg0, arg1} 13819 for _, a := range arg2 { 13820 varargs = append(varargs, a) 13821 } 13822 ret := m.ctrl.Call(m, "DetachNetworkInterfaceWithContext", varargs...) 13823 ret0, _ := ret[0].(*ec2.DetachNetworkInterfaceOutput) 13824 ret1, _ := ret[1].(error) 13825 return ret0, ret1 13826 } 13827 13828 // DetachNetworkInterfaceWithContext indicates an expected call of DetachNetworkInterfaceWithContext 13829 func (mr *MockEC2APIMockRecorder) DetachNetworkInterfaceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13830 mr.mock.ctrl.T.Helper() 13831 varargs := append([]interface{}{arg0, arg1}, arg2...) 13832 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterfaceWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterfaceWithContext), varargs...) 13833 } 13834 13835 // DetachNetworkInterfaceRequest mocks base method 13836 func (m *MockEC2API) DetachNetworkInterfaceRequest(arg0 *ec2.DetachNetworkInterfaceInput) (*request.Request, *ec2.DetachNetworkInterfaceOutput) { 13837 m.ctrl.T.Helper() 13838 ret := m.ctrl.Call(m, "DetachNetworkInterfaceRequest", arg0) 13839 ret0, _ := ret[0].(*request.Request) 13840 ret1, _ := ret[1].(*ec2.DetachNetworkInterfaceOutput) 13841 return ret0, ret1 13842 } 13843 13844 // DetachNetworkInterfaceRequest indicates an expected call of DetachNetworkInterfaceRequest 13845 func (mr *MockEC2APIMockRecorder) DetachNetworkInterfaceRequest(arg0 interface{}) *gomock.Call { 13846 mr.mock.ctrl.T.Helper() 13847 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachNetworkInterfaceRequest", reflect.TypeOf((*MockEC2API)(nil).DetachNetworkInterfaceRequest), arg0) 13848 } 13849 13850 // DetachVolume mocks base method 13851 func (m *MockEC2API) DetachVolume(arg0 *ec2.DetachVolumeInput) (*ec2.VolumeAttachment, error) { 13852 m.ctrl.T.Helper() 13853 ret := m.ctrl.Call(m, "DetachVolume", arg0) 13854 ret0, _ := ret[0].(*ec2.VolumeAttachment) 13855 ret1, _ := ret[1].(error) 13856 return ret0, ret1 13857 } 13858 13859 // DetachVolume indicates an expected call of DetachVolume 13860 func (mr *MockEC2APIMockRecorder) DetachVolume(arg0 interface{}) *gomock.Call { 13861 mr.mock.ctrl.T.Helper() 13862 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolume", reflect.TypeOf((*MockEC2API)(nil).DetachVolume), arg0) 13863 } 13864 13865 // DetachVolumeWithContext mocks base method 13866 func (m *MockEC2API) DetachVolumeWithContext(arg0 aws.Context, arg1 *ec2.DetachVolumeInput, arg2 ...request.Option) (*ec2.VolumeAttachment, error) { 13867 m.ctrl.T.Helper() 13868 varargs := []interface{}{arg0, arg1} 13869 for _, a := range arg2 { 13870 varargs = append(varargs, a) 13871 } 13872 ret := m.ctrl.Call(m, "DetachVolumeWithContext", varargs...) 13873 ret0, _ := ret[0].(*ec2.VolumeAttachment) 13874 ret1, _ := ret[1].(error) 13875 return ret0, ret1 13876 } 13877 13878 // DetachVolumeWithContext indicates an expected call of DetachVolumeWithContext 13879 func (mr *MockEC2APIMockRecorder) DetachVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13880 mr.mock.ctrl.T.Helper() 13881 varargs := append([]interface{}{arg0, arg1}, arg2...) 13882 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachVolumeWithContext), varargs...) 13883 } 13884 13885 // DetachVolumeRequest mocks base method 13886 func (m *MockEC2API) DetachVolumeRequest(arg0 *ec2.DetachVolumeInput) (*request.Request, *ec2.VolumeAttachment) { 13887 m.ctrl.T.Helper() 13888 ret := m.ctrl.Call(m, "DetachVolumeRequest", arg0) 13889 ret0, _ := ret[0].(*request.Request) 13890 ret1, _ := ret[1].(*ec2.VolumeAttachment) 13891 return ret0, ret1 13892 } 13893 13894 // DetachVolumeRequest indicates an expected call of DetachVolumeRequest 13895 func (mr *MockEC2APIMockRecorder) DetachVolumeRequest(arg0 interface{}) *gomock.Call { 13896 mr.mock.ctrl.T.Helper() 13897 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVolumeRequest), arg0) 13898 } 13899 13900 // DetachVpnGateway mocks base method 13901 func (m *MockEC2API) DetachVpnGateway(arg0 *ec2.DetachVpnGatewayInput) (*ec2.DetachVpnGatewayOutput, error) { 13902 m.ctrl.T.Helper() 13903 ret := m.ctrl.Call(m, "DetachVpnGateway", arg0) 13904 ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput) 13905 ret1, _ := ret[1].(error) 13906 return ret0, ret1 13907 } 13908 13909 // DetachVpnGateway indicates an expected call of DetachVpnGateway 13910 func (mr *MockEC2APIMockRecorder) DetachVpnGateway(arg0 interface{}) *gomock.Call { 13911 mr.mock.ctrl.T.Helper() 13912 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGateway", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGateway), arg0) 13913 } 13914 13915 // DetachVpnGatewayWithContext mocks base method 13916 func (m *MockEC2API) DetachVpnGatewayWithContext(arg0 aws.Context, arg1 *ec2.DetachVpnGatewayInput, arg2 ...request.Option) (*ec2.DetachVpnGatewayOutput, error) { 13917 m.ctrl.T.Helper() 13918 varargs := []interface{}{arg0, arg1} 13919 for _, a := range arg2 { 13920 varargs = append(varargs, a) 13921 } 13922 ret := m.ctrl.Call(m, "DetachVpnGatewayWithContext", varargs...) 13923 ret0, _ := ret[0].(*ec2.DetachVpnGatewayOutput) 13924 ret1, _ := ret[1].(error) 13925 return ret0, ret1 13926 } 13927 13928 // DetachVpnGatewayWithContext indicates an expected call of DetachVpnGatewayWithContext 13929 func (mr *MockEC2APIMockRecorder) DetachVpnGatewayWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13930 mr.mock.ctrl.T.Helper() 13931 varargs := append([]interface{}{arg0, arg1}, arg2...) 13932 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGatewayWithContext", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGatewayWithContext), varargs...) 13933 } 13934 13935 // DetachVpnGatewayRequest mocks base method 13936 func (m *MockEC2API) DetachVpnGatewayRequest(arg0 *ec2.DetachVpnGatewayInput) (*request.Request, *ec2.DetachVpnGatewayOutput) { 13937 m.ctrl.T.Helper() 13938 ret := m.ctrl.Call(m, "DetachVpnGatewayRequest", arg0) 13939 ret0, _ := ret[0].(*request.Request) 13940 ret1, _ := ret[1].(*ec2.DetachVpnGatewayOutput) 13941 return ret0, ret1 13942 } 13943 13944 // DetachVpnGatewayRequest indicates an expected call of DetachVpnGatewayRequest 13945 func (mr *MockEC2APIMockRecorder) DetachVpnGatewayRequest(arg0 interface{}) *gomock.Call { 13946 mr.mock.ctrl.T.Helper() 13947 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DetachVpnGatewayRequest", reflect.TypeOf((*MockEC2API)(nil).DetachVpnGatewayRequest), arg0) 13948 } 13949 13950 // DisableEbsEncryptionByDefault mocks base method 13951 func (m *MockEC2API) DisableEbsEncryptionByDefault(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*ec2.DisableEbsEncryptionByDefaultOutput, error) { 13952 m.ctrl.T.Helper() 13953 ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefault", arg0) 13954 ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput) 13955 ret1, _ := ret[1].(error) 13956 return ret0, ret1 13957 } 13958 13959 // DisableEbsEncryptionByDefault indicates an expected call of DisableEbsEncryptionByDefault 13960 func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { 13961 mr.mock.ctrl.T.Helper() 13962 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefault), arg0) 13963 } 13964 13965 // DisableEbsEncryptionByDefaultWithContext mocks base method 13966 func (m *MockEC2API) DisableEbsEncryptionByDefaultWithContext(arg0 aws.Context, arg1 *ec2.DisableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.DisableEbsEncryptionByDefaultOutput, error) { 13967 m.ctrl.T.Helper() 13968 varargs := []interface{}{arg0, arg1} 13969 for _, a := range arg2 { 13970 varargs = append(varargs, a) 13971 } 13972 ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultWithContext", varargs...) 13973 ret0, _ := ret[0].(*ec2.DisableEbsEncryptionByDefaultOutput) 13974 ret1, _ := ret[1].(error) 13975 return ret0, ret1 13976 } 13977 13978 // DisableEbsEncryptionByDefaultWithContext indicates an expected call of DisableEbsEncryptionByDefaultWithContext 13979 func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 13980 mr.mock.ctrl.T.Helper() 13981 varargs := append([]interface{}{arg0, arg1}, arg2...) 13982 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefaultWithContext), varargs...) 13983 } 13984 13985 // DisableEbsEncryptionByDefaultRequest mocks base method 13986 func (m *MockEC2API) DisableEbsEncryptionByDefaultRequest(arg0 *ec2.DisableEbsEncryptionByDefaultInput) (*request.Request, *ec2.DisableEbsEncryptionByDefaultOutput) { 13987 m.ctrl.T.Helper() 13988 ret := m.ctrl.Call(m, "DisableEbsEncryptionByDefaultRequest", arg0) 13989 ret0, _ := ret[0].(*request.Request) 13990 ret1, _ := ret[1].(*ec2.DisableEbsEncryptionByDefaultOutput) 13991 return ret0, ret1 13992 } 13993 13994 // DisableEbsEncryptionByDefaultRequest indicates an expected call of DisableEbsEncryptionByDefaultRequest 13995 func (mr *MockEC2APIMockRecorder) DisableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { 13996 mr.mock.ctrl.T.Helper() 13997 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).DisableEbsEncryptionByDefaultRequest), arg0) 13998 } 13999 14000 // DisableTransitGatewayRouteTablePropagation mocks base method 14001 func (m *MockEC2API) DisableTransitGatewayRouteTablePropagation(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) { 14002 m.ctrl.T.Helper() 14003 ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagation", arg0) 14004 ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) 14005 ret1, _ := ret[1].(error) 14006 return ret0, ret1 14007 } 14008 14009 // DisableTransitGatewayRouteTablePropagation indicates an expected call of DisableTransitGatewayRouteTablePropagation 14010 func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call { 14011 mr.mock.ctrl.T.Helper() 14012 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagation), arg0) 14013 } 14014 14015 // DisableTransitGatewayRouteTablePropagationWithContext mocks base method 14016 func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationWithContext(arg0 aws.Context, arg1 *ec2.DisableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.DisableTransitGatewayRouteTablePropagationOutput, error) { 14017 m.ctrl.T.Helper() 14018 varargs := []interface{}{arg0, arg1} 14019 for _, a := range arg2 { 14020 varargs = append(varargs, a) 14021 } 14022 ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationWithContext", varargs...) 14023 ret0, _ := ret[0].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) 14024 ret1, _ := ret[1].(error) 14025 return ret0, ret1 14026 } 14027 14028 // DisableTransitGatewayRouteTablePropagationWithContext indicates an expected call of DisableTransitGatewayRouteTablePropagationWithContext 14029 func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14030 mr.mock.ctrl.T.Helper() 14031 varargs := append([]interface{}{arg0, arg1}, arg2...) 14032 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationWithContext), varargs...) 14033 } 14034 14035 // DisableTransitGatewayRouteTablePropagationRequest mocks base method 14036 func (m *MockEC2API) DisableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.DisableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.DisableTransitGatewayRouteTablePropagationOutput) { 14037 m.ctrl.T.Helper() 14038 ret := m.ctrl.Call(m, "DisableTransitGatewayRouteTablePropagationRequest", arg0) 14039 ret0, _ := ret[0].(*request.Request) 14040 ret1, _ := ret[1].(*ec2.DisableTransitGatewayRouteTablePropagationOutput) 14041 return ret0, ret1 14042 } 14043 14044 // DisableTransitGatewayRouteTablePropagationRequest indicates an expected call of DisableTransitGatewayRouteTablePropagationRequest 14045 func (mr *MockEC2APIMockRecorder) DisableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call { 14046 mr.mock.ctrl.T.Helper() 14047 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableTransitGatewayRouteTablePropagationRequest), arg0) 14048 } 14049 14050 // DisableVgwRoutePropagation mocks base method 14051 func (m *MockEC2API) DisableVgwRoutePropagation(arg0 *ec2.DisableVgwRoutePropagationInput) (*ec2.DisableVgwRoutePropagationOutput, error) { 14052 m.ctrl.T.Helper() 14053 ret := m.ctrl.Call(m, "DisableVgwRoutePropagation", arg0) 14054 ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput) 14055 ret1, _ := ret[1].(error) 14056 return ret0, ret1 14057 } 14058 14059 // DisableVgwRoutePropagation indicates an expected call of DisableVgwRoutePropagation 14060 func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagation(arg0 interface{}) *gomock.Call { 14061 mr.mock.ctrl.T.Helper() 14062 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagation), arg0) 14063 } 14064 14065 // DisableVgwRoutePropagationWithContext mocks base method 14066 func (m *MockEC2API) DisableVgwRoutePropagationWithContext(arg0 aws.Context, arg1 *ec2.DisableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.DisableVgwRoutePropagationOutput, error) { 14067 m.ctrl.T.Helper() 14068 varargs := []interface{}{arg0, arg1} 14069 for _, a := range arg2 { 14070 varargs = append(varargs, a) 14071 } 14072 ret := m.ctrl.Call(m, "DisableVgwRoutePropagationWithContext", varargs...) 14073 ret0, _ := ret[0].(*ec2.DisableVgwRoutePropagationOutput) 14074 ret1, _ := ret[1].(error) 14075 return ret0, ret1 14076 } 14077 14078 // DisableVgwRoutePropagationWithContext indicates an expected call of DisableVgwRoutePropagationWithContext 14079 func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14080 mr.mock.ctrl.T.Helper() 14081 varargs := append([]interface{}{arg0, arg1}, arg2...) 14082 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagationWithContext), varargs...) 14083 } 14084 14085 // DisableVgwRoutePropagationRequest mocks base method 14086 func (m *MockEC2API) DisableVgwRoutePropagationRequest(arg0 *ec2.DisableVgwRoutePropagationInput) (*request.Request, *ec2.DisableVgwRoutePropagationOutput) { 14087 m.ctrl.T.Helper() 14088 ret := m.ctrl.Call(m, "DisableVgwRoutePropagationRequest", arg0) 14089 ret0, _ := ret[0].(*request.Request) 14090 ret1, _ := ret[1].(*ec2.DisableVgwRoutePropagationOutput) 14091 return ret0, ret1 14092 } 14093 14094 // DisableVgwRoutePropagationRequest indicates an expected call of DisableVgwRoutePropagationRequest 14095 func (mr *MockEC2APIMockRecorder) DisableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call { 14096 mr.mock.ctrl.T.Helper() 14097 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVgwRoutePropagationRequest), arg0) 14098 } 14099 14100 // DisableVpcClassicLink mocks base method 14101 func (m *MockEC2API) DisableVpcClassicLink(arg0 *ec2.DisableVpcClassicLinkInput) (*ec2.DisableVpcClassicLinkOutput, error) { 14102 m.ctrl.T.Helper() 14103 ret := m.ctrl.Call(m, "DisableVpcClassicLink", arg0) 14104 ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput) 14105 ret1, _ := ret[1].(error) 14106 return ret0, ret1 14107 } 14108 14109 // DisableVpcClassicLink indicates an expected call of DisableVpcClassicLink 14110 func (mr *MockEC2APIMockRecorder) DisableVpcClassicLink(arg0 interface{}) *gomock.Call { 14111 mr.mock.ctrl.T.Helper() 14112 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLink), arg0) 14113 } 14114 14115 // DisableVpcClassicLinkWithContext mocks base method 14116 func (m *MockEC2API) DisableVpcClassicLinkWithContext(arg0 aws.Context, arg1 *ec2.DisableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkOutput, error) { 14117 m.ctrl.T.Helper() 14118 varargs := []interface{}{arg0, arg1} 14119 for _, a := range arg2 { 14120 varargs = append(varargs, a) 14121 } 14122 ret := m.ctrl.Call(m, "DisableVpcClassicLinkWithContext", varargs...) 14123 ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkOutput) 14124 ret1, _ := ret[1].(error) 14125 return ret0, ret1 14126 } 14127 14128 // DisableVpcClassicLinkWithContext indicates an expected call of DisableVpcClassicLinkWithContext 14129 func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14130 mr.mock.ctrl.T.Helper() 14131 varargs := append([]interface{}{arg0, arg1}, arg2...) 14132 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkWithContext), varargs...) 14133 } 14134 14135 // DisableVpcClassicLinkRequest mocks base method 14136 func (m *MockEC2API) DisableVpcClassicLinkRequest(arg0 *ec2.DisableVpcClassicLinkInput) (*request.Request, *ec2.DisableVpcClassicLinkOutput) { 14137 m.ctrl.T.Helper() 14138 ret := m.ctrl.Call(m, "DisableVpcClassicLinkRequest", arg0) 14139 ret0, _ := ret[0].(*request.Request) 14140 ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkOutput) 14141 return ret0, ret1 14142 } 14143 14144 // DisableVpcClassicLinkRequest indicates an expected call of DisableVpcClassicLinkRequest 14145 func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { 14146 mr.mock.ctrl.T.Helper() 14147 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkRequest), arg0) 14148 } 14149 14150 // DisableVpcClassicLinkDnsSupport mocks base method 14151 func (m *MockEC2API) DisableVpcClassicLinkDnsSupport(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) { 14152 m.ctrl.T.Helper() 14153 ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupport", arg0) 14154 ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput) 14155 ret1, _ := ret[1].(error) 14156 return ret0, ret1 14157 } 14158 14159 // DisableVpcClassicLinkDnsSupport indicates an expected call of DisableVpcClassicLinkDnsSupport 14160 func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { 14161 mr.mock.ctrl.T.Helper() 14162 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupport), arg0) 14163 } 14164 14165 // DisableVpcClassicLinkDnsSupportWithContext mocks base method 14166 func (m *MockEC2API) DisableVpcClassicLinkDnsSupportWithContext(arg0 aws.Context, arg1 *ec2.DisableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.DisableVpcClassicLinkDnsSupportOutput, error) { 14167 m.ctrl.T.Helper() 14168 varargs := []interface{}{arg0, arg1} 14169 for _, a := range arg2 { 14170 varargs = append(varargs, a) 14171 } 14172 ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportWithContext", varargs...) 14173 ret0, _ := ret[0].(*ec2.DisableVpcClassicLinkDnsSupportOutput) 14174 ret1, _ := ret[1].(error) 14175 return ret0, ret1 14176 } 14177 14178 // DisableVpcClassicLinkDnsSupportWithContext indicates an expected call of DisableVpcClassicLinkDnsSupportWithContext 14179 func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14180 mr.mock.ctrl.T.Helper() 14181 varargs := append([]interface{}{arg0, arg1}, arg2...) 14182 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportWithContext), varargs...) 14183 } 14184 14185 // DisableVpcClassicLinkDnsSupportRequest mocks base method 14186 func (m *MockEC2API) DisableVpcClassicLinkDnsSupportRequest(arg0 *ec2.DisableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.DisableVpcClassicLinkDnsSupportOutput) { 14187 m.ctrl.T.Helper() 14188 ret := m.ctrl.Call(m, "DisableVpcClassicLinkDnsSupportRequest", arg0) 14189 ret0, _ := ret[0].(*request.Request) 14190 ret1, _ := ret[1].(*ec2.DisableVpcClassicLinkDnsSupportOutput) 14191 return ret0, ret1 14192 } 14193 14194 // DisableVpcClassicLinkDnsSupportRequest indicates an expected call of DisableVpcClassicLinkDnsSupportRequest 14195 func (mr *MockEC2APIMockRecorder) DisableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { 14196 mr.mock.ctrl.T.Helper() 14197 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).DisableVpcClassicLinkDnsSupportRequest), arg0) 14198 } 14199 14200 // DisassociateAddress mocks base method 14201 func (m *MockEC2API) DisassociateAddress(arg0 *ec2.DisassociateAddressInput) (*ec2.DisassociateAddressOutput, error) { 14202 m.ctrl.T.Helper() 14203 ret := m.ctrl.Call(m, "DisassociateAddress", arg0) 14204 ret0, _ := ret[0].(*ec2.DisassociateAddressOutput) 14205 ret1, _ := ret[1].(error) 14206 return ret0, ret1 14207 } 14208 14209 // DisassociateAddress indicates an expected call of DisassociateAddress 14210 func (mr *MockEC2APIMockRecorder) DisassociateAddress(arg0 interface{}) *gomock.Call { 14211 mr.mock.ctrl.T.Helper() 14212 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddress", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddress), arg0) 14213 } 14214 14215 // DisassociateAddressWithContext mocks base method 14216 func (m *MockEC2API) DisassociateAddressWithContext(arg0 aws.Context, arg1 *ec2.DisassociateAddressInput, arg2 ...request.Option) (*ec2.DisassociateAddressOutput, error) { 14217 m.ctrl.T.Helper() 14218 varargs := []interface{}{arg0, arg1} 14219 for _, a := range arg2 { 14220 varargs = append(varargs, a) 14221 } 14222 ret := m.ctrl.Call(m, "DisassociateAddressWithContext", varargs...) 14223 ret0, _ := ret[0].(*ec2.DisassociateAddressOutput) 14224 ret1, _ := ret[1].(error) 14225 return ret0, ret1 14226 } 14227 14228 // DisassociateAddressWithContext indicates an expected call of DisassociateAddressWithContext 14229 func (mr *MockEC2APIMockRecorder) DisassociateAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14230 mr.mock.ctrl.T.Helper() 14231 varargs := append([]interface{}{arg0, arg1}, arg2...) 14232 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddressWithContext), varargs...) 14233 } 14234 14235 // DisassociateAddressRequest mocks base method 14236 func (m *MockEC2API) DisassociateAddressRequest(arg0 *ec2.DisassociateAddressInput) (*request.Request, *ec2.DisassociateAddressOutput) { 14237 m.ctrl.T.Helper() 14238 ret := m.ctrl.Call(m, "DisassociateAddressRequest", arg0) 14239 ret0, _ := ret[0].(*request.Request) 14240 ret1, _ := ret[1].(*ec2.DisassociateAddressOutput) 14241 return ret0, ret1 14242 } 14243 14244 // DisassociateAddressRequest indicates an expected call of DisassociateAddressRequest 14245 func (mr *MockEC2APIMockRecorder) DisassociateAddressRequest(arg0 interface{}) *gomock.Call { 14246 mr.mock.ctrl.T.Helper() 14247 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateAddressRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateAddressRequest), arg0) 14248 } 14249 14250 // DisassociateClientVpnTargetNetwork mocks base method 14251 func (m *MockEC2API) DisassociateClientVpnTargetNetwork(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) { 14252 m.ctrl.T.Helper() 14253 ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetwork", arg0) 14254 ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput) 14255 ret1, _ := ret[1].(error) 14256 return ret0, ret1 14257 } 14258 14259 // DisassociateClientVpnTargetNetwork indicates an expected call of DisassociateClientVpnTargetNetwork 14260 func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetwork(arg0 interface{}) *gomock.Call { 14261 mr.mock.ctrl.T.Helper() 14262 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetwork", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetwork), arg0) 14263 } 14264 14265 // DisassociateClientVpnTargetNetworkWithContext mocks base method 14266 func (m *MockEC2API) DisassociateClientVpnTargetNetworkWithContext(arg0 aws.Context, arg1 *ec2.DisassociateClientVpnTargetNetworkInput, arg2 ...request.Option) (*ec2.DisassociateClientVpnTargetNetworkOutput, error) { 14267 m.ctrl.T.Helper() 14268 varargs := []interface{}{arg0, arg1} 14269 for _, a := range arg2 { 14270 varargs = append(varargs, a) 14271 } 14272 ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkWithContext", varargs...) 14273 ret0, _ := ret[0].(*ec2.DisassociateClientVpnTargetNetworkOutput) 14274 ret1, _ := ret[1].(error) 14275 return ret0, ret1 14276 } 14277 14278 // DisassociateClientVpnTargetNetworkWithContext indicates an expected call of DisassociateClientVpnTargetNetworkWithContext 14279 func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14280 mr.mock.ctrl.T.Helper() 14281 varargs := append([]interface{}{arg0, arg1}, arg2...) 14282 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkWithContext), varargs...) 14283 } 14284 14285 // DisassociateClientVpnTargetNetworkRequest mocks base method 14286 func (m *MockEC2API) DisassociateClientVpnTargetNetworkRequest(arg0 *ec2.DisassociateClientVpnTargetNetworkInput) (*request.Request, *ec2.DisassociateClientVpnTargetNetworkOutput) { 14287 m.ctrl.T.Helper() 14288 ret := m.ctrl.Call(m, "DisassociateClientVpnTargetNetworkRequest", arg0) 14289 ret0, _ := ret[0].(*request.Request) 14290 ret1, _ := ret[1].(*ec2.DisassociateClientVpnTargetNetworkOutput) 14291 return ret0, ret1 14292 } 14293 14294 // DisassociateClientVpnTargetNetworkRequest indicates an expected call of DisassociateClientVpnTargetNetworkRequest 14295 func (mr *MockEC2APIMockRecorder) DisassociateClientVpnTargetNetworkRequest(arg0 interface{}) *gomock.Call { 14296 mr.mock.ctrl.T.Helper() 14297 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateClientVpnTargetNetworkRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateClientVpnTargetNetworkRequest), arg0) 14298 } 14299 14300 // DisassociateIamInstanceProfile mocks base method 14301 func (m *MockEC2API) DisassociateIamInstanceProfile(arg0 *ec2.DisassociateIamInstanceProfileInput) (*ec2.DisassociateIamInstanceProfileOutput, error) { 14302 m.ctrl.T.Helper() 14303 ret := m.ctrl.Call(m, "DisassociateIamInstanceProfile", arg0) 14304 ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput) 14305 ret1, _ := ret[1].(error) 14306 return ret0, ret1 14307 } 14308 14309 // DisassociateIamInstanceProfile indicates an expected call of DisassociateIamInstanceProfile 14310 func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfile(arg0 interface{}) *gomock.Call { 14311 mr.mock.ctrl.T.Helper() 14312 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfile", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfile), arg0) 14313 } 14314 14315 // DisassociateIamInstanceProfileWithContext mocks base method 14316 func (m *MockEC2API) DisassociateIamInstanceProfileWithContext(arg0 aws.Context, arg1 *ec2.DisassociateIamInstanceProfileInput, arg2 ...request.Option) (*ec2.DisassociateIamInstanceProfileOutput, error) { 14317 m.ctrl.T.Helper() 14318 varargs := []interface{}{arg0, arg1} 14319 for _, a := range arg2 { 14320 varargs = append(varargs, a) 14321 } 14322 ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileWithContext", varargs...) 14323 ret0, _ := ret[0].(*ec2.DisassociateIamInstanceProfileOutput) 14324 ret1, _ := ret[1].(error) 14325 return ret0, ret1 14326 } 14327 14328 // DisassociateIamInstanceProfileWithContext indicates an expected call of DisassociateIamInstanceProfileWithContext 14329 func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfileWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14330 mr.mock.ctrl.T.Helper() 14331 varargs := append([]interface{}{arg0, arg1}, arg2...) 14332 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfileWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfileWithContext), varargs...) 14333 } 14334 14335 // DisassociateIamInstanceProfileRequest mocks base method 14336 func (m *MockEC2API) DisassociateIamInstanceProfileRequest(arg0 *ec2.DisassociateIamInstanceProfileInput) (*request.Request, *ec2.DisassociateIamInstanceProfileOutput) { 14337 m.ctrl.T.Helper() 14338 ret := m.ctrl.Call(m, "DisassociateIamInstanceProfileRequest", arg0) 14339 ret0, _ := ret[0].(*request.Request) 14340 ret1, _ := ret[1].(*ec2.DisassociateIamInstanceProfileOutput) 14341 return ret0, ret1 14342 } 14343 14344 // DisassociateIamInstanceProfileRequest indicates an expected call of DisassociateIamInstanceProfileRequest 14345 func (mr *MockEC2APIMockRecorder) DisassociateIamInstanceProfileRequest(arg0 interface{}) *gomock.Call { 14346 mr.mock.ctrl.T.Helper() 14347 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateIamInstanceProfileRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateIamInstanceProfileRequest), arg0) 14348 } 14349 14350 // DisassociateRouteTable mocks base method 14351 func (m *MockEC2API) DisassociateRouteTable(arg0 *ec2.DisassociateRouteTableInput) (*ec2.DisassociateRouteTableOutput, error) { 14352 m.ctrl.T.Helper() 14353 ret := m.ctrl.Call(m, "DisassociateRouteTable", arg0) 14354 ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput) 14355 ret1, _ := ret[1].(error) 14356 return ret0, ret1 14357 } 14358 14359 // DisassociateRouteTable indicates an expected call of DisassociateRouteTable 14360 func (mr *MockEC2APIMockRecorder) DisassociateRouteTable(arg0 interface{}) *gomock.Call { 14361 mr.mock.ctrl.T.Helper() 14362 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTable), arg0) 14363 } 14364 14365 // DisassociateRouteTableWithContext mocks base method 14366 func (m *MockEC2API) DisassociateRouteTableWithContext(arg0 aws.Context, arg1 *ec2.DisassociateRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateRouteTableOutput, error) { 14367 m.ctrl.T.Helper() 14368 varargs := []interface{}{arg0, arg1} 14369 for _, a := range arg2 { 14370 varargs = append(varargs, a) 14371 } 14372 ret := m.ctrl.Call(m, "DisassociateRouteTableWithContext", varargs...) 14373 ret0, _ := ret[0].(*ec2.DisassociateRouteTableOutput) 14374 ret1, _ := ret[1].(error) 14375 return ret0, ret1 14376 } 14377 14378 // DisassociateRouteTableWithContext indicates an expected call of DisassociateRouteTableWithContext 14379 func (mr *MockEC2APIMockRecorder) DisassociateRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14380 mr.mock.ctrl.T.Helper() 14381 varargs := append([]interface{}{arg0, arg1}, arg2...) 14382 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTableWithContext), varargs...) 14383 } 14384 14385 // DisassociateRouteTableRequest mocks base method 14386 func (m *MockEC2API) DisassociateRouteTableRequest(arg0 *ec2.DisassociateRouteTableInput) (*request.Request, *ec2.DisassociateRouteTableOutput) { 14387 m.ctrl.T.Helper() 14388 ret := m.ctrl.Call(m, "DisassociateRouteTableRequest", arg0) 14389 ret0, _ := ret[0].(*request.Request) 14390 ret1, _ := ret[1].(*ec2.DisassociateRouteTableOutput) 14391 return ret0, ret1 14392 } 14393 14394 // DisassociateRouteTableRequest indicates an expected call of DisassociateRouteTableRequest 14395 func (mr *MockEC2APIMockRecorder) DisassociateRouteTableRequest(arg0 interface{}) *gomock.Call { 14396 mr.mock.ctrl.T.Helper() 14397 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateRouteTableRequest), arg0) 14398 } 14399 14400 // DisassociateSubnetCidrBlock mocks base method 14401 func (m *MockEC2API) DisassociateSubnetCidrBlock(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*ec2.DisassociateSubnetCidrBlockOutput, error) { 14402 m.ctrl.T.Helper() 14403 ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlock", arg0) 14404 ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput) 14405 ret1, _ := ret[1].(error) 14406 return ret0, ret1 14407 } 14408 14409 // DisassociateSubnetCidrBlock indicates an expected call of DisassociateSubnetCidrBlock 14410 func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlock(arg0 interface{}) *gomock.Call { 14411 mr.mock.ctrl.T.Helper() 14412 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlock), arg0) 14413 } 14414 14415 // DisassociateSubnetCidrBlockWithContext mocks base method 14416 func (m *MockEC2API) DisassociateSubnetCidrBlockWithContext(arg0 aws.Context, arg1 *ec2.DisassociateSubnetCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateSubnetCidrBlockOutput, error) { 14417 m.ctrl.T.Helper() 14418 varargs := []interface{}{arg0, arg1} 14419 for _, a := range arg2 { 14420 varargs = append(varargs, a) 14421 } 14422 ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockWithContext", varargs...) 14423 ret0, _ := ret[0].(*ec2.DisassociateSubnetCidrBlockOutput) 14424 ret1, _ := ret[1].(error) 14425 return ret0, ret1 14426 } 14427 14428 // DisassociateSubnetCidrBlockWithContext indicates an expected call of DisassociateSubnetCidrBlockWithContext 14429 func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14430 mr.mock.ctrl.T.Helper() 14431 varargs := append([]interface{}{arg0, arg1}, arg2...) 14432 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlockWithContext), varargs...) 14433 } 14434 14435 // DisassociateSubnetCidrBlockRequest mocks base method 14436 func (m *MockEC2API) DisassociateSubnetCidrBlockRequest(arg0 *ec2.DisassociateSubnetCidrBlockInput) (*request.Request, *ec2.DisassociateSubnetCidrBlockOutput) { 14437 m.ctrl.T.Helper() 14438 ret := m.ctrl.Call(m, "DisassociateSubnetCidrBlockRequest", arg0) 14439 ret0, _ := ret[0].(*request.Request) 14440 ret1, _ := ret[1].(*ec2.DisassociateSubnetCidrBlockOutput) 14441 return ret0, ret1 14442 } 14443 14444 // DisassociateSubnetCidrBlockRequest indicates an expected call of DisassociateSubnetCidrBlockRequest 14445 func (mr *MockEC2APIMockRecorder) DisassociateSubnetCidrBlockRequest(arg0 interface{}) *gomock.Call { 14446 mr.mock.ctrl.T.Helper() 14447 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateSubnetCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateSubnetCidrBlockRequest), arg0) 14448 } 14449 14450 // DisassociateTransitGatewayRouteTable mocks base method 14451 func (m *MockEC2API) DisassociateTransitGatewayRouteTable(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) { 14452 m.ctrl.T.Helper() 14453 ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTable", arg0) 14454 ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput) 14455 ret1, _ := ret[1].(error) 14456 return ret0, ret1 14457 } 14458 14459 // DisassociateTransitGatewayRouteTable indicates an expected call of DisassociateTransitGatewayRouteTable 14460 func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTable(arg0 interface{}) *gomock.Call { 14461 mr.mock.ctrl.T.Helper() 14462 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTable", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTable), arg0) 14463 } 14464 14465 // DisassociateTransitGatewayRouteTableWithContext mocks base method 14466 func (m *MockEC2API) DisassociateTransitGatewayRouteTableWithContext(arg0 aws.Context, arg1 *ec2.DisassociateTransitGatewayRouteTableInput, arg2 ...request.Option) (*ec2.DisassociateTransitGatewayRouteTableOutput, error) { 14467 m.ctrl.T.Helper() 14468 varargs := []interface{}{arg0, arg1} 14469 for _, a := range arg2 { 14470 varargs = append(varargs, a) 14471 } 14472 ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableWithContext", varargs...) 14473 ret0, _ := ret[0].(*ec2.DisassociateTransitGatewayRouteTableOutput) 14474 ret1, _ := ret[1].(error) 14475 return ret0, ret1 14476 } 14477 14478 // DisassociateTransitGatewayRouteTableWithContext indicates an expected call of DisassociateTransitGatewayRouteTableWithContext 14479 func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14480 mr.mock.ctrl.T.Helper() 14481 varargs := append([]interface{}{arg0, arg1}, arg2...) 14482 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableWithContext), varargs...) 14483 } 14484 14485 // DisassociateTransitGatewayRouteTableRequest mocks base method 14486 func (m *MockEC2API) DisassociateTransitGatewayRouteTableRequest(arg0 *ec2.DisassociateTransitGatewayRouteTableInput) (*request.Request, *ec2.DisassociateTransitGatewayRouteTableOutput) { 14487 m.ctrl.T.Helper() 14488 ret := m.ctrl.Call(m, "DisassociateTransitGatewayRouteTableRequest", arg0) 14489 ret0, _ := ret[0].(*request.Request) 14490 ret1, _ := ret[1].(*ec2.DisassociateTransitGatewayRouteTableOutput) 14491 return ret0, ret1 14492 } 14493 14494 // DisassociateTransitGatewayRouteTableRequest indicates an expected call of DisassociateTransitGatewayRouteTableRequest 14495 func (mr *MockEC2APIMockRecorder) DisassociateTransitGatewayRouteTableRequest(arg0 interface{}) *gomock.Call { 14496 mr.mock.ctrl.T.Helper() 14497 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateTransitGatewayRouteTableRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateTransitGatewayRouteTableRequest), arg0) 14498 } 14499 14500 // DisassociateVpcCidrBlock mocks base method 14501 func (m *MockEC2API) DisassociateVpcCidrBlock(arg0 *ec2.DisassociateVpcCidrBlockInput) (*ec2.DisassociateVpcCidrBlockOutput, error) { 14502 m.ctrl.T.Helper() 14503 ret := m.ctrl.Call(m, "DisassociateVpcCidrBlock", arg0) 14504 ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput) 14505 ret1, _ := ret[1].(error) 14506 return ret0, ret1 14507 } 14508 14509 // DisassociateVpcCidrBlock indicates an expected call of DisassociateVpcCidrBlock 14510 func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlock(arg0 interface{}) *gomock.Call { 14511 mr.mock.ctrl.T.Helper() 14512 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlock", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlock), arg0) 14513 } 14514 14515 // DisassociateVpcCidrBlockWithContext mocks base method 14516 func (m *MockEC2API) DisassociateVpcCidrBlockWithContext(arg0 aws.Context, arg1 *ec2.DisassociateVpcCidrBlockInput, arg2 ...request.Option) (*ec2.DisassociateVpcCidrBlockOutput, error) { 14517 m.ctrl.T.Helper() 14518 varargs := []interface{}{arg0, arg1} 14519 for _, a := range arg2 { 14520 varargs = append(varargs, a) 14521 } 14522 ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockWithContext", varargs...) 14523 ret0, _ := ret[0].(*ec2.DisassociateVpcCidrBlockOutput) 14524 ret1, _ := ret[1].(error) 14525 return ret0, ret1 14526 } 14527 14528 // DisassociateVpcCidrBlockWithContext indicates an expected call of DisassociateVpcCidrBlockWithContext 14529 func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14530 mr.mock.ctrl.T.Helper() 14531 varargs := append([]interface{}{arg0, arg1}, arg2...) 14532 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockWithContext", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockWithContext), varargs...) 14533 } 14534 14535 // DisassociateVpcCidrBlockRequest mocks base method 14536 func (m *MockEC2API) DisassociateVpcCidrBlockRequest(arg0 *ec2.DisassociateVpcCidrBlockInput) (*request.Request, *ec2.DisassociateVpcCidrBlockOutput) { 14537 m.ctrl.T.Helper() 14538 ret := m.ctrl.Call(m, "DisassociateVpcCidrBlockRequest", arg0) 14539 ret0, _ := ret[0].(*request.Request) 14540 ret1, _ := ret[1].(*ec2.DisassociateVpcCidrBlockOutput) 14541 return ret0, ret1 14542 } 14543 14544 // DisassociateVpcCidrBlockRequest indicates an expected call of DisassociateVpcCidrBlockRequest 14545 func (mr *MockEC2APIMockRecorder) DisassociateVpcCidrBlockRequest(arg0 interface{}) *gomock.Call { 14546 mr.mock.ctrl.T.Helper() 14547 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisassociateVpcCidrBlockRequest", reflect.TypeOf((*MockEC2API)(nil).DisassociateVpcCidrBlockRequest), arg0) 14548 } 14549 14550 // EnableEbsEncryptionByDefault mocks base method 14551 func (m *MockEC2API) EnableEbsEncryptionByDefault(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { 14552 m.ctrl.T.Helper() 14553 ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefault", arg0) 14554 ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) 14555 ret1, _ := ret[1].(error) 14556 return ret0, ret1 14557 } 14558 14559 // EnableEbsEncryptionByDefault indicates an expected call of EnableEbsEncryptionByDefault 14560 func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { 14561 mr.mock.ctrl.T.Helper() 14562 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefault), arg0) 14563 } 14564 14565 // EnableEbsEncryptionByDefaultWithContext mocks base method 14566 func (m *MockEC2API) EnableEbsEncryptionByDefaultWithContext(arg0 aws.Context, arg1 *ec2.EnableEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.EnableEbsEncryptionByDefaultOutput, error) { 14567 m.ctrl.T.Helper() 14568 varargs := []interface{}{arg0, arg1} 14569 for _, a := range arg2 { 14570 varargs = append(varargs, a) 14571 } 14572 ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultWithContext", varargs...) 14573 ret0, _ := ret[0].(*ec2.EnableEbsEncryptionByDefaultOutput) 14574 ret1, _ := ret[1].(error) 14575 return ret0, ret1 14576 } 14577 14578 // EnableEbsEncryptionByDefaultWithContext indicates an expected call of EnableEbsEncryptionByDefaultWithContext 14579 func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14580 mr.mock.ctrl.T.Helper() 14581 varargs := append([]interface{}{arg0, arg1}, arg2...) 14582 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultWithContext), varargs...) 14583 } 14584 14585 // EnableEbsEncryptionByDefaultRequest mocks base method 14586 func (m *MockEC2API) EnableEbsEncryptionByDefaultRequest(arg0 *ec2.EnableEbsEncryptionByDefaultInput) (*request.Request, *ec2.EnableEbsEncryptionByDefaultOutput) { 14587 m.ctrl.T.Helper() 14588 ret := m.ctrl.Call(m, "EnableEbsEncryptionByDefaultRequest", arg0) 14589 ret0, _ := ret[0].(*request.Request) 14590 ret1, _ := ret[1].(*ec2.EnableEbsEncryptionByDefaultOutput) 14591 return ret0, ret1 14592 } 14593 14594 // EnableEbsEncryptionByDefaultRequest indicates an expected call of EnableEbsEncryptionByDefaultRequest 14595 func (mr *MockEC2APIMockRecorder) EnableEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { 14596 mr.mock.ctrl.T.Helper() 14597 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).EnableEbsEncryptionByDefaultRequest), arg0) 14598 } 14599 14600 // EnableTransitGatewayRouteTablePropagation mocks base method 14601 func (m *MockEC2API) EnableTransitGatewayRouteTablePropagation(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) { 14602 m.ctrl.T.Helper() 14603 ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagation", arg0) 14604 ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) 14605 ret1, _ := ret[1].(error) 14606 return ret0, ret1 14607 } 14608 14609 // EnableTransitGatewayRouteTablePropagation indicates an expected call of EnableTransitGatewayRouteTablePropagation 14610 func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagation(arg0 interface{}) *gomock.Call { 14611 mr.mock.ctrl.T.Helper() 14612 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagation), arg0) 14613 } 14614 14615 // EnableTransitGatewayRouteTablePropagationWithContext mocks base method 14616 func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationWithContext(arg0 aws.Context, arg1 *ec2.EnableTransitGatewayRouteTablePropagationInput, arg2 ...request.Option) (*ec2.EnableTransitGatewayRouteTablePropagationOutput, error) { 14617 m.ctrl.T.Helper() 14618 varargs := []interface{}{arg0, arg1} 14619 for _, a := range arg2 { 14620 varargs = append(varargs, a) 14621 } 14622 ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationWithContext", varargs...) 14623 ret0, _ := ret[0].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) 14624 ret1, _ := ret[1].(error) 14625 return ret0, ret1 14626 } 14627 14628 // EnableTransitGatewayRouteTablePropagationWithContext indicates an expected call of EnableTransitGatewayRouteTablePropagationWithContext 14629 func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14630 mr.mock.ctrl.T.Helper() 14631 varargs := append([]interface{}{arg0, arg1}, arg2...) 14632 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationWithContext), varargs...) 14633 } 14634 14635 // EnableTransitGatewayRouteTablePropagationRequest mocks base method 14636 func (m *MockEC2API) EnableTransitGatewayRouteTablePropagationRequest(arg0 *ec2.EnableTransitGatewayRouteTablePropagationInput) (*request.Request, *ec2.EnableTransitGatewayRouteTablePropagationOutput) { 14637 m.ctrl.T.Helper() 14638 ret := m.ctrl.Call(m, "EnableTransitGatewayRouteTablePropagationRequest", arg0) 14639 ret0, _ := ret[0].(*request.Request) 14640 ret1, _ := ret[1].(*ec2.EnableTransitGatewayRouteTablePropagationOutput) 14641 return ret0, ret1 14642 } 14643 14644 // EnableTransitGatewayRouteTablePropagationRequest indicates an expected call of EnableTransitGatewayRouteTablePropagationRequest 14645 func (mr *MockEC2APIMockRecorder) EnableTransitGatewayRouteTablePropagationRequest(arg0 interface{}) *gomock.Call { 14646 mr.mock.ctrl.T.Helper() 14647 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableTransitGatewayRouteTablePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableTransitGatewayRouteTablePropagationRequest), arg0) 14648 } 14649 14650 // EnableVgwRoutePropagation mocks base method 14651 func (m *MockEC2API) EnableVgwRoutePropagation(arg0 *ec2.EnableVgwRoutePropagationInput) (*ec2.EnableVgwRoutePropagationOutput, error) { 14652 m.ctrl.T.Helper() 14653 ret := m.ctrl.Call(m, "EnableVgwRoutePropagation", arg0) 14654 ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput) 14655 ret1, _ := ret[1].(error) 14656 return ret0, ret1 14657 } 14658 14659 // EnableVgwRoutePropagation indicates an expected call of EnableVgwRoutePropagation 14660 func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagation(arg0 interface{}) *gomock.Call { 14661 mr.mock.ctrl.T.Helper() 14662 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagation", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagation), arg0) 14663 } 14664 14665 // EnableVgwRoutePropagationWithContext mocks base method 14666 func (m *MockEC2API) EnableVgwRoutePropagationWithContext(arg0 aws.Context, arg1 *ec2.EnableVgwRoutePropagationInput, arg2 ...request.Option) (*ec2.EnableVgwRoutePropagationOutput, error) { 14667 m.ctrl.T.Helper() 14668 varargs := []interface{}{arg0, arg1} 14669 for _, a := range arg2 { 14670 varargs = append(varargs, a) 14671 } 14672 ret := m.ctrl.Call(m, "EnableVgwRoutePropagationWithContext", varargs...) 14673 ret0, _ := ret[0].(*ec2.EnableVgwRoutePropagationOutput) 14674 ret1, _ := ret[1].(error) 14675 return ret0, ret1 14676 } 14677 14678 // EnableVgwRoutePropagationWithContext indicates an expected call of EnableVgwRoutePropagationWithContext 14679 func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14680 mr.mock.ctrl.T.Helper() 14681 varargs := append([]interface{}{arg0, arg1}, arg2...) 14682 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagationWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagationWithContext), varargs...) 14683 } 14684 14685 // EnableVgwRoutePropagationRequest mocks base method 14686 func (m *MockEC2API) EnableVgwRoutePropagationRequest(arg0 *ec2.EnableVgwRoutePropagationInput) (*request.Request, *ec2.EnableVgwRoutePropagationOutput) { 14687 m.ctrl.T.Helper() 14688 ret := m.ctrl.Call(m, "EnableVgwRoutePropagationRequest", arg0) 14689 ret0, _ := ret[0].(*request.Request) 14690 ret1, _ := ret[1].(*ec2.EnableVgwRoutePropagationOutput) 14691 return ret0, ret1 14692 } 14693 14694 // EnableVgwRoutePropagationRequest indicates an expected call of EnableVgwRoutePropagationRequest 14695 func (mr *MockEC2APIMockRecorder) EnableVgwRoutePropagationRequest(arg0 interface{}) *gomock.Call { 14696 mr.mock.ctrl.T.Helper() 14697 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVgwRoutePropagationRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVgwRoutePropagationRequest), arg0) 14698 } 14699 14700 // EnableVolumeIO mocks base method 14701 func (m *MockEC2API) EnableVolumeIO(arg0 *ec2.EnableVolumeIOInput) (*ec2.EnableVolumeIOOutput, error) { 14702 m.ctrl.T.Helper() 14703 ret := m.ctrl.Call(m, "EnableVolumeIO", arg0) 14704 ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput) 14705 ret1, _ := ret[1].(error) 14706 return ret0, ret1 14707 } 14708 14709 // EnableVolumeIO indicates an expected call of EnableVolumeIO 14710 func (mr *MockEC2APIMockRecorder) EnableVolumeIO(arg0 interface{}) *gomock.Call { 14711 mr.mock.ctrl.T.Helper() 14712 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIO", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIO), arg0) 14713 } 14714 14715 // EnableVolumeIOWithContext mocks base method 14716 func (m *MockEC2API) EnableVolumeIOWithContext(arg0 aws.Context, arg1 *ec2.EnableVolumeIOInput, arg2 ...request.Option) (*ec2.EnableVolumeIOOutput, error) { 14717 m.ctrl.T.Helper() 14718 varargs := []interface{}{arg0, arg1} 14719 for _, a := range arg2 { 14720 varargs = append(varargs, a) 14721 } 14722 ret := m.ctrl.Call(m, "EnableVolumeIOWithContext", varargs...) 14723 ret0, _ := ret[0].(*ec2.EnableVolumeIOOutput) 14724 ret1, _ := ret[1].(error) 14725 return ret0, ret1 14726 } 14727 14728 // EnableVolumeIOWithContext indicates an expected call of EnableVolumeIOWithContext 14729 func (mr *MockEC2APIMockRecorder) EnableVolumeIOWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14730 mr.mock.ctrl.T.Helper() 14731 varargs := append([]interface{}{arg0, arg1}, arg2...) 14732 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIOWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIOWithContext), varargs...) 14733 } 14734 14735 // EnableVolumeIORequest mocks base method 14736 func (m *MockEC2API) EnableVolumeIORequest(arg0 *ec2.EnableVolumeIOInput) (*request.Request, *ec2.EnableVolumeIOOutput) { 14737 m.ctrl.T.Helper() 14738 ret := m.ctrl.Call(m, "EnableVolumeIORequest", arg0) 14739 ret0, _ := ret[0].(*request.Request) 14740 ret1, _ := ret[1].(*ec2.EnableVolumeIOOutput) 14741 return ret0, ret1 14742 } 14743 14744 // EnableVolumeIORequest indicates an expected call of EnableVolumeIORequest 14745 func (mr *MockEC2APIMockRecorder) EnableVolumeIORequest(arg0 interface{}) *gomock.Call { 14746 mr.mock.ctrl.T.Helper() 14747 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVolumeIORequest", reflect.TypeOf((*MockEC2API)(nil).EnableVolumeIORequest), arg0) 14748 } 14749 14750 // EnableVpcClassicLink mocks base method 14751 func (m *MockEC2API) EnableVpcClassicLink(arg0 *ec2.EnableVpcClassicLinkInput) (*ec2.EnableVpcClassicLinkOutput, error) { 14752 m.ctrl.T.Helper() 14753 ret := m.ctrl.Call(m, "EnableVpcClassicLink", arg0) 14754 ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput) 14755 ret1, _ := ret[1].(error) 14756 return ret0, ret1 14757 } 14758 14759 // EnableVpcClassicLink indicates an expected call of EnableVpcClassicLink 14760 func (mr *MockEC2APIMockRecorder) EnableVpcClassicLink(arg0 interface{}) *gomock.Call { 14761 mr.mock.ctrl.T.Helper() 14762 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLink", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLink), arg0) 14763 } 14764 14765 // EnableVpcClassicLinkWithContext mocks base method 14766 func (m *MockEC2API) EnableVpcClassicLinkWithContext(arg0 aws.Context, arg1 *ec2.EnableVpcClassicLinkInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkOutput, error) { 14767 m.ctrl.T.Helper() 14768 varargs := []interface{}{arg0, arg1} 14769 for _, a := range arg2 { 14770 varargs = append(varargs, a) 14771 } 14772 ret := m.ctrl.Call(m, "EnableVpcClassicLinkWithContext", varargs...) 14773 ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkOutput) 14774 ret1, _ := ret[1].(error) 14775 return ret0, ret1 14776 } 14777 14778 // EnableVpcClassicLinkWithContext indicates an expected call of EnableVpcClassicLinkWithContext 14779 func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14780 mr.mock.ctrl.T.Helper() 14781 varargs := append([]interface{}{arg0, arg1}, arg2...) 14782 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkWithContext), varargs...) 14783 } 14784 14785 // EnableVpcClassicLinkRequest mocks base method 14786 func (m *MockEC2API) EnableVpcClassicLinkRequest(arg0 *ec2.EnableVpcClassicLinkInput) (*request.Request, *ec2.EnableVpcClassicLinkOutput) { 14787 m.ctrl.T.Helper() 14788 ret := m.ctrl.Call(m, "EnableVpcClassicLinkRequest", arg0) 14789 ret0, _ := ret[0].(*request.Request) 14790 ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkOutput) 14791 return ret0, ret1 14792 } 14793 14794 // EnableVpcClassicLinkRequest indicates an expected call of EnableVpcClassicLinkRequest 14795 func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkRequest(arg0 interface{}) *gomock.Call { 14796 mr.mock.ctrl.T.Helper() 14797 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkRequest), arg0) 14798 } 14799 14800 // EnableVpcClassicLinkDnsSupport mocks base method 14801 func (m *MockEC2API) EnableVpcClassicLinkDnsSupport(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) { 14802 m.ctrl.T.Helper() 14803 ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupport", arg0) 14804 ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput) 14805 ret1, _ := ret[1].(error) 14806 return ret0, ret1 14807 } 14808 14809 // EnableVpcClassicLinkDnsSupport indicates an expected call of EnableVpcClassicLinkDnsSupport 14810 func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupport(arg0 interface{}) *gomock.Call { 14811 mr.mock.ctrl.T.Helper() 14812 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupport", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupport), arg0) 14813 } 14814 14815 // EnableVpcClassicLinkDnsSupportWithContext mocks base method 14816 func (m *MockEC2API) EnableVpcClassicLinkDnsSupportWithContext(arg0 aws.Context, arg1 *ec2.EnableVpcClassicLinkDnsSupportInput, arg2 ...request.Option) (*ec2.EnableVpcClassicLinkDnsSupportOutput, error) { 14817 m.ctrl.T.Helper() 14818 varargs := []interface{}{arg0, arg1} 14819 for _, a := range arg2 { 14820 varargs = append(varargs, a) 14821 } 14822 ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportWithContext", varargs...) 14823 ret0, _ := ret[0].(*ec2.EnableVpcClassicLinkDnsSupportOutput) 14824 ret1, _ := ret[1].(error) 14825 return ret0, ret1 14826 } 14827 14828 // EnableVpcClassicLinkDnsSupportWithContext indicates an expected call of EnableVpcClassicLinkDnsSupportWithContext 14829 func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14830 mr.mock.ctrl.T.Helper() 14831 varargs := append([]interface{}{arg0, arg1}, arg2...) 14832 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportWithContext", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportWithContext), varargs...) 14833 } 14834 14835 // EnableVpcClassicLinkDnsSupportRequest mocks base method 14836 func (m *MockEC2API) EnableVpcClassicLinkDnsSupportRequest(arg0 *ec2.EnableVpcClassicLinkDnsSupportInput) (*request.Request, *ec2.EnableVpcClassicLinkDnsSupportOutput) { 14837 m.ctrl.T.Helper() 14838 ret := m.ctrl.Call(m, "EnableVpcClassicLinkDnsSupportRequest", arg0) 14839 ret0, _ := ret[0].(*request.Request) 14840 ret1, _ := ret[1].(*ec2.EnableVpcClassicLinkDnsSupportOutput) 14841 return ret0, ret1 14842 } 14843 14844 // EnableVpcClassicLinkDnsSupportRequest indicates an expected call of EnableVpcClassicLinkDnsSupportRequest 14845 func (mr *MockEC2APIMockRecorder) EnableVpcClassicLinkDnsSupportRequest(arg0 interface{}) *gomock.Call { 14846 mr.mock.ctrl.T.Helper() 14847 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableVpcClassicLinkDnsSupportRequest", reflect.TypeOf((*MockEC2API)(nil).EnableVpcClassicLinkDnsSupportRequest), arg0) 14848 } 14849 14850 // ExportClientVpnClientCertificateRevocationList mocks base method 14851 func (m *MockEC2API) ExportClientVpnClientCertificateRevocationList(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) { 14852 m.ctrl.T.Helper() 14853 ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationList", arg0) 14854 ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) 14855 ret1, _ := ret[1].(error) 14856 return ret0, ret1 14857 } 14858 14859 // ExportClientVpnClientCertificateRevocationList indicates an expected call of ExportClientVpnClientCertificateRevocationList 14860 func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call { 14861 mr.mock.ctrl.T.Helper() 14862 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationList), arg0) 14863 } 14864 14865 // ExportClientVpnClientCertificateRevocationListWithContext mocks base method 14866 func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListWithContext(arg0 aws.Context, arg1 *ec2.ExportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientCertificateRevocationListOutput, error) { 14867 m.ctrl.T.Helper() 14868 varargs := []interface{}{arg0, arg1} 14869 for _, a := range arg2 { 14870 varargs = append(varargs, a) 14871 } 14872 ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListWithContext", varargs...) 14873 ret0, _ := ret[0].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) 14874 ret1, _ := ret[1].(error) 14875 return ret0, ret1 14876 } 14877 14878 // ExportClientVpnClientCertificateRevocationListWithContext indicates an expected call of ExportClientVpnClientCertificateRevocationListWithContext 14879 func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14880 mr.mock.ctrl.T.Helper() 14881 varargs := append([]interface{}{arg0, arg1}, arg2...) 14882 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationListWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListWithContext), varargs...) 14883 } 14884 14885 // ExportClientVpnClientCertificateRevocationListRequest mocks base method 14886 func (m *MockEC2API) ExportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ExportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ExportClientVpnClientCertificateRevocationListOutput) { 14887 m.ctrl.T.Helper() 14888 ret := m.ctrl.Call(m, "ExportClientVpnClientCertificateRevocationListRequest", arg0) 14889 ret0, _ := ret[0].(*request.Request) 14890 ret1, _ := ret[1].(*ec2.ExportClientVpnClientCertificateRevocationListOutput) 14891 return ret0, ret1 14892 } 14893 14894 // ExportClientVpnClientCertificateRevocationListRequest indicates an expected call of ExportClientVpnClientCertificateRevocationListRequest 14895 func (mr *MockEC2APIMockRecorder) ExportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call { 14896 mr.mock.ctrl.T.Helper() 14897 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientCertificateRevocationListRequest), arg0) 14898 } 14899 14900 // ExportClientVpnClientConfiguration mocks base method 14901 func (m *MockEC2API) ExportClientVpnClientConfiguration(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*ec2.ExportClientVpnClientConfigurationOutput, error) { 14902 m.ctrl.T.Helper() 14903 ret := m.ctrl.Call(m, "ExportClientVpnClientConfiguration", arg0) 14904 ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput) 14905 ret1, _ := ret[1].(error) 14906 return ret0, ret1 14907 } 14908 14909 // ExportClientVpnClientConfiguration indicates an expected call of ExportClientVpnClientConfiguration 14910 func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfiguration(arg0 interface{}) *gomock.Call { 14911 mr.mock.ctrl.T.Helper() 14912 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfiguration", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfiguration), arg0) 14913 } 14914 14915 // ExportClientVpnClientConfigurationWithContext mocks base method 14916 func (m *MockEC2API) ExportClientVpnClientConfigurationWithContext(arg0 aws.Context, arg1 *ec2.ExportClientVpnClientConfigurationInput, arg2 ...request.Option) (*ec2.ExportClientVpnClientConfigurationOutput, error) { 14917 m.ctrl.T.Helper() 14918 varargs := []interface{}{arg0, arg1} 14919 for _, a := range arg2 { 14920 varargs = append(varargs, a) 14921 } 14922 ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationWithContext", varargs...) 14923 ret0, _ := ret[0].(*ec2.ExportClientVpnClientConfigurationOutput) 14924 ret1, _ := ret[1].(error) 14925 return ret0, ret1 14926 } 14927 14928 // ExportClientVpnClientConfigurationWithContext indicates an expected call of ExportClientVpnClientConfigurationWithContext 14929 func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14930 mr.mock.ctrl.T.Helper() 14931 varargs := append([]interface{}{arg0, arg1}, arg2...) 14932 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfigurationWithContext), varargs...) 14933 } 14934 14935 // ExportClientVpnClientConfigurationRequest mocks base method 14936 func (m *MockEC2API) ExportClientVpnClientConfigurationRequest(arg0 *ec2.ExportClientVpnClientConfigurationInput) (*request.Request, *ec2.ExportClientVpnClientConfigurationOutput) { 14937 m.ctrl.T.Helper() 14938 ret := m.ctrl.Call(m, "ExportClientVpnClientConfigurationRequest", arg0) 14939 ret0, _ := ret[0].(*request.Request) 14940 ret1, _ := ret[1].(*ec2.ExportClientVpnClientConfigurationOutput) 14941 return ret0, ret1 14942 } 14943 14944 // ExportClientVpnClientConfigurationRequest indicates an expected call of ExportClientVpnClientConfigurationRequest 14945 func (mr *MockEC2APIMockRecorder) ExportClientVpnClientConfigurationRequest(arg0 interface{}) *gomock.Call { 14946 mr.mock.ctrl.T.Helper() 14947 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportClientVpnClientConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ExportClientVpnClientConfigurationRequest), arg0) 14948 } 14949 14950 // ExportImage mocks base method 14951 func (m *MockEC2API) ExportImage(arg0 *ec2.ExportImageInput) (*ec2.ExportImageOutput, error) { 14952 m.ctrl.T.Helper() 14953 ret := m.ctrl.Call(m, "ExportImage", arg0) 14954 ret0, _ := ret[0].(*ec2.ExportImageOutput) 14955 ret1, _ := ret[1].(error) 14956 return ret0, ret1 14957 } 14958 14959 // ExportImage indicates an expected call of ExportImage 14960 func (mr *MockEC2APIMockRecorder) ExportImage(arg0 interface{}) *gomock.Call { 14961 mr.mock.ctrl.T.Helper() 14962 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImage", reflect.TypeOf((*MockEC2API)(nil).ExportImage), arg0) 14963 } 14964 14965 // ExportImageWithContext mocks base method 14966 func (m *MockEC2API) ExportImageWithContext(arg0 aws.Context, arg1 *ec2.ExportImageInput, arg2 ...request.Option) (*ec2.ExportImageOutput, error) { 14967 m.ctrl.T.Helper() 14968 varargs := []interface{}{arg0, arg1} 14969 for _, a := range arg2 { 14970 varargs = append(varargs, a) 14971 } 14972 ret := m.ctrl.Call(m, "ExportImageWithContext", varargs...) 14973 ret0, _ := ret[0].(*ec2.ExportImageOutput) 14974 ret1, _ := ret[1].(error) 14975 return ret0, ret1 14976 } 14977 14978 // ExportImageWithContext indicates an expected call of ExportImageWithContext 14979 func (mr *MockEC2APIMockRecorder) ExportImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 14980 mr.mock.ctrl.T.Helper() 14981 varargs := append([]interface{}{arg0, arg1}, arg2...) 14982 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImageWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportImageWithContext), varargs...) 14983 } 14984 14985 // ExportImageRequest mocks base method 14986 func (m *MockEC2API) ExportImageRequest(arg0 *ec2.ExportImageInput) (*request.Request, *ec2.ExportImageOutput) { 14987 m.ctrl.T.Helper() 14988 ret := m.ctrl.Call(m, "ExportImageRequest", arg0) 14989 ret0, _ := ret[0].(*request.Request) 14990 ret1, _ := ret[1].(*ec2.ExportImageOutput) 14991 return ret0, ret1 14992 } 14993 14994 // ExportImageRequest indicates an expected call of ExportImageRequest 14995 func (mr *MockEC2APIMockRecorder) ExportImageRequest(arg0 interface{}) *gomock.Call { 14996 mr.mock.ctrl.T.Helper() 14997 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ExportImageRequest), arg0) 14998 } 14999 15000 // ExportTransitGatewayRoutes mocks base method 15001 func (m *MockEC2API) ExportTransitGatewayRoutes(arg0 *ec2.ExportTransitGatewayRoutesInput) (*ec2.ExportTransitGatewayRoutesOutput, error) { 15002 m.ctrl.T.Helper() 15003 ret := m.ctrl.Call(m, "ExportTransitGatewayRoutes", arg0) 15004 ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput) 15005 ret1, _ := ret[1].(error) 15006 return ret0, ret1 15007 } 15008 15009 // ExportTransitGatewayRoutes indicates an expected call of ExportTransitGatewayRoutes 15010 func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutes(arg0 interface{}) *gomock.Call { 15011 mr.mock.ctrl.T.Helper() 15012 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutes), arg0) 15013 } 15014 15015 // ExportTransitGatewayRoutesWithContext mocks base method 15016 func (m *MockEC2API) ExportTransitGatewayRoutesWithContext(arg0 aws.Context, arg1 *ec2.ExportTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.ExportTransitGatewayRoutesOutput, error) { 15017 m.ctrl.T.Helper() 15018 varargs := []interface{}{arg0, arg1} 15019 for _, a := range arg2 { 15020 varargs = append(varargs, a) 15021 } 15022 ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesWithContext", varargs...) 15023 ret0, _ := ret[0].(*ec2.ExportTransitGatewayRoutesOutput) 15024 ret1, _ := ret[1].(error) 15025 return ret0, ret1 15026 } 15027 15028 // ExportTransitGatewayRoutesWithContext indicates an expected call of ExportTransitGatewayRoutesWithContext 15029 func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15030 mr.mock.ctrl.T.Helper() 15031 varargs := append([]interface{}{arg0, arg1}, arg2...) 15032 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesWithContext), varargs...) 15033 } 15034 15035 // ExportTransitGatewayRoutesRequest mocks base method 15036 func (m *MockEC2API) ExportTransitGatewayRoutesRequest(arg0 *ec2.ExportTransitGatewayRoutesInput) (*request.Request, *ec2.ExportTransitGatewayRoutesOutput) { 15037 m.ctrl.T.Helper() 15038 ret := m.ctrl.Call(m, "ExportTransitGatewayRoutesRequest", arg0) 15039 ret0, _ := ret[0].(*request.Request) 15040 ret1, _ := ret[1].(*ec2.ExportTransitGatewayRoutesOutput) 15041 return ret0, ret1 15042 } 15043 15044 // ExportTransitGatewayRoutesRequest indicates an expected call of ExportTransitGatewayRoutesRequest 15045 func (mr *MockEC2APIMockRecorder) ExportTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call { 15046 mr.mock.ctrl.T.Helper() 15047 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExportTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).ExportTransitGatewayRoutesRequest), arg0) 15048 } 15049 15050 // GetCapacityReservationUsage mocks base method 15051 func (m *MockEC2API) GetCapacityReservationUsage(arg0 *ec2.GetCapacityReservationUsageInput) (*ec2.GetCapacityReservationUsageOutput, error) { 15052 m.ctrl.T.Helper() 15053 ret := m.ctrl.Call(m, "GetCapacityReservationUsage", arg0) 15054 ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput) 15055 ret1, _ := ret[1].(error) 15056 return ret0, ret1 15057 } 15058 15059 // GetCapacityReservationUsage indicates an expected call of GetCapacityReservationUsage 15060 func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsage(arg0 interface{}) *gomock.Call { 15061 mr.mock.ctrl.T.Helper() 15062 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsage", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsage), arg0) 15063 } 15064 15065 // GetCapacityReservationUsageWithContext mocks base method 15066 func (m *MockEC2API) GetCapacityReservationUsageWithContext(arg0 aws.Context, arg1 *ec2.GetCapacityReservationUsageInput, arg2 ...request.Option) (*ec2.GetCapacityReservationUsageOutput, error) { 15067 m.ctrl.T.Helper() 15068 varargs := []interface{}{arg0, arg1} 15069 for _, a := range arg2 { 15070 varargs = append(varargs, a) 15071 } 15072 ret := m.ctrl.Call(m, "GetCapacityReservationUsageWithContext", varargs...) 15073 ret0, _ := ret[0].(*ec2.GetCapacityReservationUsageOutput) 15074 ret1, _ := ret[1].(error) 15075 return ret0, ret1 15076 } 15077 15078 // GetCapacityReservationUsageWithContext indicates an expected call of GetCapacityReservationUsageWithContext 15079 func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15080 mr.mock.ctrl.T.Helper() 15081 varargs := append([]interface{}{arg0, arg1}, arg2...) 15082 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageWithContext", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageWithContext), varargs...) 15083 } 15084 15085 // GetCapacityReservationUsageRequest mocks base method 15086 func (m *MockEC2API) GetCapacityReservationUsageRequest(arg0 *ec2.GetCapacityReservationUsageInput) (*request.Request, *ec2.GetCapacityReservationUsageOutput) { 15087 m.ctrl.T.Helper() 15088 ret := m.ctrl.Call(m, "GetCapacityReservationUsageRequest", arg0) 15089 ret0, _ := ret[0].(*request.Request) 15090 ret1, _ := ret[1].(*ec2.GetCapacityReservationUsageOutput) 15091 return ret0, ret1 15092 } 15093 15094 // GetCapacityReservationUsageRequest indicates an expected call of GetCapacityReservationUsageRequest 15095 func (mr *MockEC2APIMockRecorder) GetCapacityReservationUsageRequest(arg0 interface{}) *gomock.Call { 15096 mr.mock.ctrl.T.Helper() 15097 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCapacityReservationUsageRequest", reflect.TypeOf((*MockEC2API)(nil).GetCapacityReservationUsageRequest), arg0) 15098 } 15099 15100 // GetConsoleOutput mocks base method 15101 func (m *MockEC2API) GetConsoleOutput(arg0 *ec2.GetConsoleOutputInput) (*ec2.GetConsoleOutputOutput, error) { 15102 m.ctrl.T.Helper() 15103 ret := m.ctrl.Call(m, "GetConsoleOutput", arg0) 15104 ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput) 15105 ret1, _ := ret[1].(error) 15106 return ret0, ret1 15107 } 15108 15109 // GetConsoleOutput indicates an expected call of GetConsoleOutput 15110 func (mr *MockEC2APIMockRecorder) GetConsoleOutput(arg0 interface{}) *gomock.Call { 15111 mr.mock.ctrl.T.Helper() 15112 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutput", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutput), arg0) 15113 } 15114 15115 // GetConsoleOutputWithContext mocks base method 15116 func (m *MockEC2API) GetConsoleOutputWithContext(arg0 aws.Context, arg1 *ec2.GetConsoleOutputInput, arg2 ...request.Option) (*ec2.GetConsoleOutputOutput, error) { 15117 m.ctrl.T.Helper() 15118 varargs := []interface{}{arg0, arg1} 15119 for _, a := range arg2 { 15120 varargs = append(varargs, a) 15121 } 15122 ret := m.ctrl.Call(m, "GetConsoleOutputWithContext", varargs...) 15123 ret0, _ := ret[0].(*ec2.GetConsoleOutputOutput) 15124 ret1, _ := ret[1].(error) 15125 return ret0, ret1 15126 } 15127 15128 // GetConsoleOutputWithContext indicates an expected call of GetConsoleOutputWithContext 15129 func (mr *MockEC2APIMockRecorder) GetConsoleOutputWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15130 mr.mock.ctrl.T.Helper() 15131 varargs := append([]interface{}{arg0, arg1}, arg2...) 15132 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutputWithContext", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutputWithContext), varargs...) 15133 } 15134 15135 // GetConsoleOutputRequest mocks base method 15136 func (m *MockEC2API) GetConsoleOutputRequest(arg0 *ec2.GetConsoleOutputInput) (*request.Request, *ec2.GetConsoleOutputOutput) { 15137 m.ctrl.T.Helper() 15138 ret := m.ctrl.Call(m, "GetConsoleOutputRequest", arg0) 15139 ret0, _ := ret[0].(*request.Request) 15140 ret1, _ := ret[1].(*ec2.GetConsoleOutputOutput) 15141 return ret0, ret1 15142 } 15143 15144 // GetConsoleOutputRequest indicates an expected call of GetConsoleOutputRequest 15145 func (mr *MockEC2APIMockRecorder) GetConsoleOutputRequest(arg0 interface{}) *gomock.Call { 15146 mr.mock.ctrl.T.Helper() 15147 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleOutputRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleOutputRequest), arg0) 15148 } 15149 15150 // GetConsoleScreenshot mocks base method 15151 func (m *MockEC2API) GetConsoleScreenshot(arg0 *ec2.GetConsoleScreenshotInput) (*ec2.GetConsoleScreenshotOutput, error) { 15152 m.ctrl.T.Helper() 15153 ret := m.ctrl.Call(m, "GetConsoleScreenshot", arg0) 15154 ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput) 15155 ret1, _ := ret[1].(error) 15156 return ret0, ret1 15157 } 15158 15159 // GetConsoleScreenshot indicates an expected call of GetConsoleScreenshot 15160 func (mr *MockEC2APIMockRecorder) GetConsoleScreenshot(arg0 interface{}) *gomock.Call { 15161 mr.mock.ctrl.T.Helper() 15162 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshot", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshot), arg0) 15163 } 15164 15165 // GetConsoleScreenshotWithContext mocks base method 15166 func (m *MockEC2API) GetConsoleScreenshotWithContext(arg0 aws.Context, arg1 *ec2.GetConsoleScreenshotInput, arg2 ...request.Option) (*ec2.GetConsoleScreenshotOutput, error) { 15167 m.ctrl.T.Helper() 15168 varargs := []interface{}{arg0, arg1} 15169 for _, a := range arg2 { 15170 varargs = append(varargs, a) 15171 } 15172 ret := m.ctrl.Call(m, "GetConsoleScreenshotWithContext", varargs...) 15173 ret0, _ := ret[0].(*ec2.GetConsoleScreenshotOutput) 15174 ret1, _ := ret[1].(error) 15175 return ret0, ret1 15176 } 15177 15178 // GetConsoleScreenshotWithContext indicates an expected call of GetConsoleScreenshotWithContext 15179 func (mr *MockEC2APIMockRecorder) GetConsoleScreenshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15180 mr.mock.ctrl.T.Helper() 15181 varargs := append([]interface{}{arg0, arg1}, arg2...) 15182 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshotWithContext", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshotWithContext), varargs...) 15183 } 15184 15185 // GetConsoleScreenshotRequest mocks base method 15186 func (m *MockEC2API) GetConsoleScreenshotRequest(arg0 *ec2.GetConsoleScreenshotInput) (*request.Request, *ec2.GetConsoleScreenshotOutput) { 15187 m.ctrl.T.Helper() 15188 ret := m.ctrl.Call(m, "GetConsoleScreenshotRequest", arg0) 15189 ret0, _ := ret[0].(*request.Request) 15190 ret1, _ := ret[1].(*ec2.GetConsoleScreenshotOutput) 15191 return ret0, ret1 15192 } 15193 15194 // GetConsoleScreenshotRequest indicates an expected call of GetConsoleScreenshotRequest 15195 func (mr *MockEC2APIMockRecorder) GetConsoleScreenshotRequest(arg0 interface{}) *gomock.Call { 15196 mr.mock.ctrl.T.Helper() 15197 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetConsoleScreenshotRequest", reflect.TypeOf((*MockEC2API)(nil).GetConsoleScreenshotRequest), arg0) 15198 } 15199 15200 // GetEbsDefaultKmsKeyId mocks base method 15201 func (m *MockEC2API) GetEbsDefaultKmsKeyId(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) { 15202 m.ctrl.T.Helper() 15203 ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyId", arg0) 15204 ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput) 15205 ret1, _ := ret[1].(error) 15206 return ret0, ret1 15207 } 15208 15209 // GetEbsDefaultKmsKeyId indicates an expected call of GetEbsDefaultKmsKeyId 15210 func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { 15211 mr.mock.ctrl.T.Helper() 15212 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyId), arg0) 15213 } 15214 15215 // GetEbsDefaultKmsKeyIdWithContext mocks base method 15216 func (m *MockEC2API) GetEbsDefaultKmsKeyIdWithContext(arg0 aws.Context, arg1 *ec2.GetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.GetEbsDefaultKmsKeyIdOutput, error) { 15217 m.ctrl.T.Helper() 15218 varargs := []interface{}{arg0, arg1} 15219 for _, a := range arg2 { 15220 varargs = append(varargs, a) 15221 } 15222 ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdWithContext", varargs...) 15223 ret0, _ := ret[0].(*ec2.GetEbsDefaultKmsKeyIdOutput) 15224 ret1, _ := ret[1].(error) 15225 return ret0, ret1 15226 } 15227 15228 // GetEbsDefaultKmsKeyIdWithContext indicates an expected call of GetEbsDefaultKmsKeyIdWithContext 15229 func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15230 mr.mock.ctrl.T.Helper() 15231 varargs := append([]interface{}{arg0, arg1}, arg2...) 15232 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdWithContext), varargs...) 15233 } 15234 15235 // GetEbsDefaultKmsKeyIdRequest mocks base method 15236 func (m *MockEC2API) GetEbsDefaultKmsKeyIdRequest(arg0 *ec2.GetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.GetEbsDefaultKmsKeyIdOutput) { 15237 m.ctrl.T.Helper() 15238 ret := m.ctrl.Call(m, "GetEbsDefaultKmsKeyIdRequest", arg0) 15239 ret0, _ := ret[0].(*request.Request) 15240 ret1, _ := ret[1].(*ec2.GetEbsDefaultKmsKeyIdOutput) 15241 return ret0, ret1 15242 } 15243 15244 // GetEbsDefaultKmsKeyIdRequest indicates an expected call of GetEbsDefaultKmsKeyIdRequest 15245 func (mr *MockEC2APIMockRecorder) GetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { 15246 mr.mock.ctrl.T.Helper() 15247 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsDefaultKmsKeyIdRequest), arg0) 15248 } 15249 15250 // GetEbsEncryptionByDefault mocks base method 15251 func (m *MockEC2API) GetEbsEncryptionByDefault(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*ec2.GetEbsEncryptionByDefaultOutput, error) { 15252 m.ctrl.T.Helper() 15253 ret := m.ctrl.Call(m, "GetEbsEncryptionByDefault", arg0) 15254 ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput) 15255 ret1, _ := ret[1].(error) 15256 return ret0, ret1 15257 } 15258 15259 // GetEbsEncryptionByDefault indicates an expected call of GetEbsEncryptionByDefault 15260 func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefault(arg0 interface{}) *gomock.Call { 15261 mr.mock.ctrl.T.Helper() 15262 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefault", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefault), arg0) 15263 } 15264 15265 // GetEbsEncryptionByDefaultWithContext mocks base method 15266 func (m *MockEC2API) GetEbsEncryptionByDefaultWithContext(arg0 aws.Context, arg1 *ec2.GetEbsEncryptionByDefaultInput, arg2 ...request.Option) (*ec2.GetEbsEncryptionByDefaultOutput, error) { 15267 m.ctrl.T.Helper() 15268 varargs := []interface{}{arg0, arg1} 15269 for _, a := range arg2 { 15270 varargs = append(varargs, a) 15271 } 15272 ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultWithContext", varargs...) 15273 ret0, _ := ret[0].(*ec2.GetEbsEncryptionByDefaultOutput) 15274 ret1, _ := ret[1].(error) 15275 return ret0, ret1 15276 } 15277 15278 // GetEbsEncryptionByDefaultWithContext indicates an expected call of GetEbsEncryptionByDefaultWithContext 15279 func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15280 mr.mock.ctrl.T.Helper() 15281 varargs := append([]interface{}{arg0, arg1}, arg2...) 15282 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultWithContext", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultWithContext), varargs...) 15283 } 15284 15285 // GetEbsEncryptionByDefaultRequest mocks base method 15286 func (m *MockEC2API) GetEbsEncryptionByDefaultRequest(arg0 *ec2.GetEbsEncryptionByDefaultInput) (*request.Request, *ec2.GetEbsEncryptionByDefaultOutput) { 15287 m.ctrl.T.Helper() 15288 ret := m.ctrl.Call(m, "GetEbsEncryptionByDefaultRequest", arg0) 15289 ret0, _ := ret[0].(*request.Request) 15290 ret1, _ := ret[1].(*ec2.GetEbsEncryptionByDefaultOutput) 15291 return ret0, ret1 15292 } 15293 15294 // GetEbsEncryptionByDefaultRequest indicates an expected call of GetEbsEncryptionByDefaultRequest 15295 func (mr *MockEC2APIMockRecorder) GetEbsEncryptionByDefaultRequest(arg0 interface{}) *gomock.Call { 15296 mr.mock.ctrl.T.Helper() 15297 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEbsEncryptionByDefaultRequest", reflect.TypeOf((*MockEC2API)(nil).GetEbsEncryptionByDefaultRequest), arg0) 15298 } 15299 15300 // GetHostReservationPurchasePreview mocks base method 15301 func (m *MockEC2API) GetHostReservationPurchasePreview(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*ec2.GetHostReservationPurchasePreviewOutput, error) { 15302 m.ctrl.T.Helper() 15303 ret := m.ctrl.Call(m, "GetHostReservationPurchasePreview", arg0) 15304 ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput) 15305 ret1, _ := ret[1].(error) 15306 return ret0, ret1 15307 } 15308 15309 // GetHostReservationPurchasePreview indicates an expected call of GetHostReservationPurchasePreview 15310 func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreview(arg0 interface{}) *gomock.Call { 15311 mr.mock.ctrl.T.Helper() 15312 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreview", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreview), arg0) 15313 } 15314 15315 // GetHostReservationPurchasePreviewWithContext mocks base method 15316 func (m *MockEC2API) GetHostReservationPurchasePreviewWithContext(arg0 aws.Context, arg1 *ec2.GetHostReservationPurchasePreviewInput, arg2 ...request.Option) (*ec2.GetHostReservationPurchasePreviewOutput, error) { 15317 m.ctrl.T.Helper() 15318 varargs := []interface{}{arg0, arg1} 15319 for _, a := range arg2 { 15320 varargs = append(varargs, a) 15321 } 15322 ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewWithContext", varargs...) 15323 ret0, _ := ret[0].(*ec2.GetHostReservationPurchasePreviewOutput) 15324 ret1, _ := ret[1].(error) 15325 return ret0, ret1 15326 } 15327 15328 // GetHostReservationPurchasePreviewWithContext indicates an expected call of GetHostReservationPurchasePreviewWithContext 15329 func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreviewWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15330 mr.mock.ctrl.T.Helper() 15331 varargs := append([]interface{}{arg0, arg1}, arg2...) 15332 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreviewWithContext", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreviewWithContext), varargs...) 15333 } 15334 15335 // GetHostReservationPurchasePreviewRequest mocks base method 15336 func (m *MockEC2API) GetHostReservationPurchasePreviewRequest(arg0 *ec2.GetHostReservationPurchasePreviewInput) (*request.Request, *ec2.GetHostReservationPurchasePreviewOutput) { 15337 m.ctrl.T.Helper() 15338 ret := m.ctrl.Call(m, "GetHostReservationPurchasePreviewRequest", arg0) 15339 ret0, _ := ret[0].(*request.Request) 15340 ret1, _ := ret[1].(*ec2.GetHostReservationPurchasePreviewOutput) 15341 return ret0, ret1 15342 } 15343 15344 // GetHostReservationPurchasePreviewRequest indicates an expected call of GetHostReservationPurchasePreviewRequest 15345 func (mr *MockEC2APIMockRecorder) GetHostReservationPurchasePreviewRequest(arg0 interface{}) *gomock.Call { 15346 mr.mock.ctrl.T.Helper() 15347 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetHostReservationPurchasePreviewRequest", reflect.TypeOf((*MockEC2API)(nil).GetHostReservationPurchasePreviewRequest), arg0) 15348 } 15349 15350 // GetLaunchTemplateData mocks base method 15351 func (m *MockEC2API) GetLaunchTemplateData(arg0 *ec2.GetLaunchTemplateDataInput) (*ec2.GetLaunchTemplateDataOutput, error) { 15352 m.ctrl.T.Helper() 15353 ret := m.ctrl.Call(m, "GetLaunchTemplateData", arg0) 15354 ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput) 15355 ret1, _ := ret[1].(error) 15356 return ret0, ret1 15357 } 15358 15359 // GetLaunchTemplateData indicates an expected call of GetLaunchTemplateData 15360 func (mr *MockEC2APIMockRecorder) GetLaunchTemplateData(arg0 interface{}) *gomock.Call { 15361 mr.mock.ctrl.T.Helper() 15362 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateData", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateData), arg0) 15363 } 15364 15365 // GetLaunchTemplateDataWithContext mocks base method 15366 func (m *MockEC2API) GetLaunchTemplateDataWithContext(arg0 aws.Context, arg1 *ec2.GetLaunchTemplateDataInput, arg2 ...request.Option) (*ec2.GetLaunchTemplateDataOutput, error) { 15367 m.ctrl.T.Helper() 15368 varargs := []interface{}{arg0, arg1} 15369 for _, a := range arg2 { 15370 varargs = append(varargs, a) 15371 } 15372 ret := m.ctrl.Call(m, "GetLaunchTemplateDataWithContext", varargs...) 15373 ret0, _ := ret[0].(*ec2.GetLaunchTemplateDataOutput) 15374 ret1, _ := ret[1].(error) 15375 return ret0, ret1 15376 } 15377 15378 // GetLaunchTemplateDataWithContext indicates an expected call of GetLaunchTemplateDataWithContext 15379 func (mr *MockEC2APIMockRecorder) GetLaunchTemplateDataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15380 mr.mock.ctrl.T.Helper() 15381 varargs := append([]interface{}{arg0, arg1}, arg2...) 15382 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateDataWithContext", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateDataWithContext), varargs...) 15383 } 15384 15385 // GetLaunchTemplateDataRequest mocks base method 15386 func (m *MockEC2API) GetLaunchTemplateDataRequest(arg0 *ec2.GetLaunchTemplateDataInput) (*request.Request, *ec2.GetLaunchTemplateDataOutput) { 15387 m.ctrl.T.Helper() 15388 ret := m.ctrl.Call(m, "GetLaunchTemplateDataRequest", arg0) 15389 ret0, _ := ret[0].(*request.Request) 15390 ret1, _ := ret[1].(*ec2.GetLaunchTemplateDataOutput) 15391 return ret0, ret1 15392 } 15393 15394 // GetLaunchTemplateDataRequest indicates an expected call of GetLaunchTemplateDataRequest 15395 func (mr *MockEC2APIMockRecorder) GetLaunchTemplateDataRequest(arg0 interface{}) *gomock.Call { 15396 mr.mock.ctrl.T.Helper() 15397 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetLaunchTemplateDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetLaunchTemplateDataRequest), arg0) 15398 } 15399 15400 // GetPasswordData mocks base method 15401 func (m *MockEC2API) GetPasswordData(arg0 *ec2.GetPasswordDataInput) (*ec2.GetPasswordDataOutput, error) { 15402 m.ctrl.T.Helper() 15403 ret := m.ctrl.Call(m, "GetPasswordData", arg0) 15404 ret0, _ := ret[0].(*ec2.GetPasswordDataOutput) 15405 ret1, _ := ret[1].(error) 15406 return ret0, ret1 15407 } 15408 15409 // GetPasswordData indicates an expected call of GetPasswordData 15410 func (mr *MockEC2APIMockRecorder) GetPasswordData(arg0 interface{}) *gomock.Call { 15411 mr.mock.ctrl.T.Helper() 15412 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordData", reflect.TypeOf((*MockEC2API)(nil).GetPasswordData), arg0) 15413 } 15414 15415 // GetPasswordDataWithContext mocks base method 15416 func (m *MockEC2API) GetPasswordDataWithContext(arg0 aws.Context, arg1 *ec2.GetPasswordDataInput, arg2 ...request.Option) (*ec2.GetPasswordDataOutput, error) { 15417 m.ctrl.T.Helper() 15418 varargs := []interface{}{arg0, arg1} 15419 for _, a := range arg2 { 15420 varargs = append(varargs, a) 15421 } 15422 ret := m.ctrl.Call(m, "GetPasswordDataWithContext", varargs...) 15423 ret0, _ := ret[0].(*ec2.GetPasswordDataOutput) 15424 ret1, _ := ret[1].(error) 15425 return ret0, ret1 15426 } 15427 15428 // GetPasswordDataWithContext indicates an expected call of GetPasswordDataWithContext 15429 func (mr *MockEC2APIMockRecorder) GetPasswordDataWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15430 mr.mock.ctrl.T.Helper() 15431 varargs := append([]interface{}{arg0, arg1}, arg2...) 15432 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordDataWithContext", reflect.TypeOf((*MockEC2API)(nil).GetPasswordDataWithContext), varargs...) 15433 } 15434 15435 // GetPasswordDataRequest mocks base method 15436 func (m *MockEC2API) GetPasswordDataRequest(arg0 *ec2.GetPasswordDataInput) (*request.Request, *ec2.GetPasswordDataOutput) { 15437 m.ctrl.T.Helper() 15438 ret := m.ctrl.Call(m, "GetPasswordDataRequest", arg0) 15439 ret0, _ := ret[0].(*request.Request) 15440 ret1, _ := ret[1].(*ec2.GetPasswordDataOutput) 15441 return ret0, ret1 15442 } 15443 15444 // GetPasswordDataRequest indicates an expected call of GetPasswordDataRequest 15445 func (mr *MockEC2APIMockRecorder) GetPasswordDataRequest(arg0 interface{}) *gomock.Call { 15446 mr.mock.ctrl.T.Helper() 15447 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPasswordDataRequest", reflect.TypeOf((*MockEC2API)(nil).GetPasswordDataRequest), arg0) 15448 } 15449 15450 // GetReservedInstancesExchangeQuote mocks base method 15451 func (m *MockEC2API) GetReservedInstancesExchangeQuote(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) { 15452 m.ctrl.T.Helper() 15453 ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuote", arg0) 15454 ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput) 15455 ret1, _ := ret[1].(error) 15456 return ret0, ret1 15457 } 15458 15459 // GetReservedInstancesExchangeQuote indicates an expected call of GetReservedInstancesExchangeQuote 15460 func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuote(arg0 interface{}) *gomock.Call { 15461 mr.mock.ctrl.T.Helper() 15462 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuote", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuote), arg0) 15463 } 15464 15465 // GetReservedInstancesExchangeQuoteWithContext mocks base method 15466 func (m *MockEC2API) GetReservedInstancesExchangeQuoteWithContext(arg0 aws.Context, arg1 *ec2.GetReservedInstancesExchangeQuoteInput, arg2 ...request.Option) (*ec2.GetReservedInstancesExchangeQuoteOutput, error) { 15467 m.ctrl.T.Helper() 15468 varargs := []interface{}{arg0, arg1} 15469 for _, a := range arg2 { 15470 varargs = append(varargs, a) 15471 } 15472 ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteWithContext", varargs...) 15473 ret0, _ := ret[0].(*ec2.GetReservedInstancesExchangeQuoteOutput) 15474 ret1, _ := ret[1].(error) 15475 return ret0, ret1 15476 } 15477 15478 // GetReservedInstancesExchangeQuoteWithContext indicates an expected call of GetReservedInstancesExchangeQuoteWithContext 15479 func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15480 mr.mock.ctrl.T.Helper() 15481 varargs := append([]interface{}{arg0, arg1}, arg2...) 15482 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteWithContext", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteWithContext), varargs...) 15483 } 15484 15485 // GetReservedInstancesExchangeQuoteRequest mocks base method 15486 func (m *MockEC2API) GetReservedInstancesExchangeQuoteRequest(arg0 *ec2.GetReservedInstancesExchangeQuoteInput) (*request.Request, *ec2.GetReservedInstancesExchangeQuoteOutput) { 15487 m.ctrl.T.Helper() 15488 ret := m.ctrl.Call(m, "GetReservedInstancesExchangeQuoteRequest", arg0) 15489 ret0, _ := ret[0].(*request.Request) 15490 ret1, _ := ret[1].(*ec2.GetReservedInstancesExchangeQuoteOutput) 15491 return ret0, ret1 15492 } 15493 15494 // GetReservedInstancesExchangeQuoteRequest indicates an expected call of GetReservedInstancesExchangeQuoteRequest 15495 func (mr *MockEC2APIMockRecorder) GetReservedInstancesExchangeQuoteRequest(arg0 interface{}) *gomock.Call { 15496 mr.mock.ctrl.T.Helper() 15497 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetReservedInstancesExchangeQuoteRequest", reflect.TypeOf((*MockEC2API)(nil).GetReservedInstancesExchangeQuoteRequest), arg0) 15498 } 15499 15500 // GetTransitGatewayAttachmentPropagations mocks base method 15501 func (m *MockEC2API) GetTransitGatewayAttachmentPropagations(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) { 15502 m.ctrl.T.Helper() 15503 ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagations", arg0) 15504 ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) 15505 ret1, _ := ret[1].(error) 15506 return ret0, ret1 15507 } 15508 15509 // GetTransitGatewayAttachmentPropagations indicates an expected call of GetTransitGatewayAttachmentPropagations 15510 func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagations(arg0 interface{}) *gomock.Call { 15511 mr.mock.ctrl.T.Helper() 15512 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagations), arg0) 15513 } 15514 15515 // GetTransitGatewayAttachmentPropagationsWithContext mocks base method 15516 func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsWithContext(arg0 aws.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayAttachmentPropagationsOutput, error) { 15517 m.ctrl.T.Helper() 15518 varargs := []interface{}{arg0, arg1} 15519 for _, a := range arg2 { 15520 varargs = append(varargs, a) 15521 } 15522 ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsWithContext", varargs...) 15523 ret0, _ := ret[0].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) 15524 ret1, _ := ret[1].(error) 15525 return ret0, ret1 15526 } 15527 15528 // GetTransitGatewayAttachmentPropagationsWithContext indicates an expected call of GetTransitGatewayAttachmentPropagationsWithContext 15529 func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15530 mr.mock.ctrl.T.Helper() 15531 varargs := append([]interface{}{arg0, arg1}, arg2...) 15532 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsWithContext), varargs...) 15533 } 15534 15535 // GetTransitGatewayAttachmentPropagationsRequest mocks base method 15536 func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsRequest(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput) (*request.Request, *ec2.GetTransitGatewayAttachmentPropagationsOutput) { 15537 m.ctrl.T.Helper() 15538 ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsRequest", arg0) 15539 ret0, _ := ret[0].(*request.Request) 15540 ret1, _ := ret[1].(*ec2.GetTransitGatewayAttachmentPropagationsOutput) 15541 return ret0, ret1 15542 } 15543 15544 // GetTransitGatewayAttachmentPropagationsRequest indicates an expected call of GetTransitGatewayAttachmentPropagationsRequest 15545 func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsRequest(arg0 interface{}) *gomock.Call { 15546 mr.mock.ctrl.T.Helper() 15547 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsRequest), arg0) 15548 } 15549 15550 // GetTransitGatewayAttachmentPropagationsPages mocks base method 15551 func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPages(arg0 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg1 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool) error { 15552 m.ctrl.T.Helper() 15553 ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsPages", arg0, arg1) 15554 ret0, _ := ret[0].(error) 15555 return ret0 15556 } 15557 15558 // GetTransitGatewayAttachmentPropagationsPages indicates an expected call of GetTransitGatewayAttachmentPropagationsPages 15559 func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsPages(arg0, arg1 interface{}) *gomock.Call { 15560 mr.mock.ctrl.T.Helper() 15561 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPages), arg0, arg1) 15562 } 15563 15564 // GetTransitGatewayAttachmentPropagationsPagesWithContext mocks base method 15565 func (m *MockEC2API) GetTransitGatewayAttachmentPropagationsPagesWithContext(arg0 aws.Context, arg1 *ec2.GetTransitGatewayAttachmentPropagationsInput, arg2 func(*ec2.GetTransitGatewayAttachmentPropagationsOutput, bool) bool, arg3 ...request.Option) error { 15566 m.ctrl.T.Helper() 15567 varargs := []interface{}{arg0, arg1, arg2} 15568 for _, a := range arg3 { 15569 varargs = append(varargs, a) 15570 } 15571 ret := m.ctrl.Call(m, "GetTransitGatewayAttachmentPropagationsPagesWithContext", varargs...) 15572 ret0, _ := ret[0].(error) 15573 return ret0 15574 } 15575 15576 // GetTransitGatewayAttachmentPropagationsPagesWithContext indicates an expected call of GetTransitGatewayAttachmentPropagationsPagesWithContext 15577 func (mr *MockEC2APIMockRecorder) GetTransitGatewayAttachmentPropagationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 15578 mr.mock.ctrl.T.Helper() 15579 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 15580 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayAttachmentPropagationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayAttachmentPropagationsPagesWithContext), varargs...) 15581 } 15582 15583 // GetTransitGatewayRouteTableAssociations mocks base method 15584 func (m *MockEC2API) GetTransitGatewayRouteTableAssociations(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) { 15585 m.ctrl.T.Helper() 15586 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociations", arg0) 15587 ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) 15588 ret1, _ := ret[1].(error) 15589 return ret0, ret1 15590 } 15591 15592 // GetTransitGatewayRouteTableAssociations indicates an expected call of GetTransitGatewayRouteTableAssociations 15593 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociations(arg0 interface{}) *gomock.Call { 15594 mr.mock.ctrl.T.Helper() 15595 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociations), arg0) 15596 } 15597 15598 // GetTransitGatewayRouteTableAssociationsWithContext mocks base method 15599 func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsWithContext(arg0 aws.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTableAssociationsOutput, error) { 15600 m.ctrl.T.Helper() 15601 varargs := []interface{}{arg0, arg1} 15602 for _, a := range arg2 { 15603 varargs = append(varargs, a) 15604 } 15605 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsWithContext", varargs...) 15606 ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) 15607 ret1, _ := ret[1].(error) 15608 return ret0, ret1 15609 } 15610 15611 // GetTransitGatewayRouteTableAssociationsWithContext indicates an expected call of GetTransitGatewayRouteTableAssociationsWithContext 15612 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15613 mr.mock.ctrl.T.Helper() 15614 varargs := append([]interface{}{arg0, arg1}, arg2...) 15615 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsWithContext), varargs...) 15616 } 15617 15618 // GetTransitGatewayRouteTableAssociationsRequest mocks base method 15619 func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsRequest(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTableAssociationsOutput) { 15620 m.ctrl.T.Helper() 15621 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsRequest", arg0) 15622 ret0, _ := ret[0].(*request.Request) 15623 ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTableAssociationsOutput) 15624 return ret0, ret1 15625 } 15626 15627 // GetTransitGatewayRouteTableAssociationsRequest indicates an expected call of GetTransitGatewayRouteTableAssociationsRequest 15628 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsRequest(arg0 interface{}) *gomock.Call { 15629 mr.mock.ctrl.T.Helper() 15630 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsRequest), arg0) 15631 } 15632 15633 // GetTransitGatewayRouteTableAssociationsPages mocks base method 15634 func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPages(arg0 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg1 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool) error { 15635 m.ctrl.T.Helper() 15636 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsPages", arg0, arg1) 15637 ret0, _ := ret[0].(error) 15638 return ret0 15639 } 15640 15641 // GetTransitGatewayRouteTableAssociationsPages indicates an expected call of GetTransitGatewayRouteTableAssociationsPages 15642 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsPages(arg0, arg1 interface{}) *gomock.Call { 15643 mr.mock.ctrl.T.Helper() 15644 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPages), arg0, arg1) 15645 } 15646 15647 // GetTransitGatewayRouteTableAssociationsPagesWithContext mocks base method 15648 func (m *MockEC2API) GetTransitGatewayRouteTableAssociationsPagesWithContext(arg0 aws.Context, arg1 *ec2.GetTransitGatewayRouteTableAssociationsInput, arg2 func(*ec2.GetTransitGatewayRouteTableAssociationsOutput, bool) bool, arg3 ...request.Option) error { 15649 m.ctrl.T.Helper() 15650 varargs := []interface{}{arg0, arg1, arg2} 15651 for _, a := range arg3 { 15652 varargs = append(varargs, a) 15653 } 15654 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTableAssociationsPagesWithContext", varargs...) 15655 ret0, _ := ret[0].(error) 15656 return ret0 15657 } 15658 15659 // GetTransitGatewayRouteTableAssociationsPagesWithContext indicates an expected call of GetTransitGatewayRouteTableAssociationsPagesWithContext 15660 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTableAssociationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 15661 mr.mock.ctrl.T.Helper() 15662 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 15663 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTableAssociationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTableAssociationsPagesWithContext), varargs...) 15664 } 15665 15666 // GetTransitGatewayRouteTablePropagations mocks base method 15667 func (m *MockEC2API) GetTransitGatewayRouteTablePropagations(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) { 15668 m.ctrl.T.Helper() 15669 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagations", arg0) 15670 ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) 15671 ret1, _ := ret[1].(error) 15672 return ret0, ret1 15673 } 15674 15675 // GetTransitGatewayRouteTablePropagations indicates an expected call of GetTransitGatewayRouteTablePropagations 15676 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagations(arg0 interface{}) *gomock.Call { 15677 mr.mock.ctrl.T.Helper() 15678 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagations", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagations), arg0) 15679 } 15680 15681 // GetTransitGatewayRouteTablePropagationsWithContext mocks base method 15682 func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsWithContext(arg0 aws.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 ...request.Option) (*ec2.GetTransitGatewayRouteTablePropagationsOutput, error) { 15683 m.ctrl.T.Helper() 15684 varargs := []interface{}{arg0, arg1} 15685 for _, a := range arg2 { 15686 varargs = append(varargs, a) 15687 } 15688 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsWithContext", varargs...) 15689 ret0, _ := ret[0].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) 15690 ret1, _ := ret[1].(error) 15691 return ret0, ret1 15692 } 15693 15694 // GetTransitGatewayRouteTablePropagationsWithContext indicates an expected call of GetTransitGatewayRouteTablePropagationsWithContext 15695 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15696 mr.mock.ctrl.T.Helper() 15697 varargs := append([]interface{}{arg0, arg1}, arg2...) 15698 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsWithContext), varargs...) 15699 } 15700 15701 // GetTransitGatewayRouteTablePropagationsRequest mocks base method 15702 func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsRequest(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput) (*request.Request, *ec2.GetTransitGatewayRouteTablePropagationsOutput) { 15703 m.ctrl.T.Helper() 15704 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsRequest", arg0) 15705 ret0, _ := ret[0].(*request.Request) 15706 ret1, _ := ret[1].(*ec2.GetTransitGatewayRouteTablePropagationsOutput) 15707 return ret0, ret1 15708 } 15709 15710 // GetTransitGatewayRouteTablePropagationsRequest indicates an expected call of GetTransitGatewayRouteTablePropagationsRequest 15711 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsRequest(arg0 interface{}) *gomock.Call { 15712 mr.mock.ctrl.T.Helper() 15713 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsRequest", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsRequest), arg0) 15714 } 15715 15716 // GetTransitGatewayRouteTablePropagationsPages mocks base method 15717 func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPages(arg0 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg1 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool) error { 15718 m.ctrl.T.Helper() 15719 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsPages", arg0, arg1) 15720 ret0, _ := ret[0].(error) 15721 return ret0 15722 } 15723 15724 // GetTransitGatewayRouteTablePropagationsPages indicates an expected call of GetTransitGatewayRouteTablePropagationsPages 15725 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsPages(arg0, arg1 interface{}) *gomock.Call { 15726 mr.mock.ctrl.T.Helper() 15727 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsPages", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPages), arg0, arg1) 15728 } 15729 15730 // GetTransitGatewayRouteTablePropagationsPagesWithContext mocks base method 15731 func (m *MockEC2API) GetTransitGatewayRouteTablePropagationsPagesWithContext(arg0 aws.Context, arg1 *ec2.GetTransitGatewayRouteTablePropagationsInput, arg2 func(*ec2.GetTransitGatewayRouteTablePropagationsOutput, bool) bool, arg3 ...request.Option) error { 15732 m.ctrl.T.Helper() 15733 varargs := []interface{}{arg0, arg1, arg2} 15734 for _, a := range arg3 { 15735 varargs = append(varargs, a) 15736 } 15737 ret := m.ctrl.Call(m, "GetTransitGatewayRouteTablePropagationsPagesWithContext", varargs...) 15738 ret0, _ := ret[0].(error) 15739 return ret0 15740 } 15741 15742 // GetTransitGatewayRouteTablePropagationsPagesWithContext indicates an expected call of GetTransitGatewayRouteTablePropagationsPagesWithContext 15743 func (mr *MockEC2APIMockRecorder) GetTransitGatewayRouteTablePropagationsPagesWithContext(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call { 15744 mr.mock.ctrl.T.Helper() 15745 varargs := append([]interface{}{arg0, arg1, arg2}, arg3...) 15746 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransitGatewayRouteTablePropagationsPagesWithContext", reflect.TypeOf((*MockEC2API)(nil).GetTransitGatewayRouteTablePropagationsPagesWithContext), varargs...) 15747 } 15748 15749 // ImportClientVpnClientCertificateRevocationList mocks base method 15750 func (m *MockEC2API) ImportClientVpnClientCertificateRevocationList(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) { 15751 m.ctrl.T.Helper() 15752 ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationList", arg0) 15753 ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) 15754 ret1, _ := ret[1].(error) 15755 return ret0, ret1 15756 } 15757 15758 // ImportClientVpnClientCertificateRevocationList indicates an expected call of ImportClientVpnClientCertificateRevocationList 15759 func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationList(arg0 interface{}) *gomock.Call { 15760 mr.mock.ctrl.T.Helper() 15761 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationList", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationList), arg0) 15762 } 15763 15764 // ImportClientVpnClientCertificateRevocationListWithContext mocks base method 15765 func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListWithContext(arg0 aws.Context, arg1 *ec2.ImportClientVpnClientCertificateRevocationListInput, arg2 ...request.Option) (*ec2.ImportClientVpnClientCertificateRevocationListOutput, error) { 15766 m.ctrl.T.Helper() 15767 varargs := []interface{}{arg0, arg1} 15768 for _, a := range arg2 { 15769 varargs = append(varargs, a) 15770 } 15771 ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListWithContext", varargs...) 15772 ret0, _ := ret[0].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) 15773 ret1, _ := ret[1].(error) 15774 return ret0, ret1 15775 } 15776 15777 // ImportClientVpnClientCertificateRevocationListWithContext indicates an expected call of ImportClientVpnClientCertificateRevocationListWithContext 15778 func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationListWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15779 mr.mock.ctrl.T.Helper() 15780 varargs := append([]interface{}{arg0, arg1}, arg2...) 15781 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationListWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListWithContext), varargs...) 15782 } 15783 15784 // ImportClientVpnClientCertificateRevocationListRequest mocks base method 15785 func (m *MockEC2API) ImportClientVpnClientCertificateRevocationListRequest(arg0 *ec2.ImportClientVpnClientCertificateRevocationListInput) (*request.Request, *ec2.ImportClientVpnClientCertificateRevocationListOutput) { 15786 m.ctrl.T.Helper() 15787 ret := m.ctrl.Call(m, "ImportClientVpnClientCertificateRevocationListRequest", arg0) 15788 ret0, _ := ret[0].(*request.Request) 15789 ret1, _ := ret[1].(*ec2.ImportClientVpnClientCertificateRevocationListOutput) 15790 return ret0, ret1 15791 } 15792 15793 // ImportClientVpnClientCertificateRevocationListRequest indicates an expected call of ImportClientVpnClientCertificateRevocationListRequest 15794 func (mr *MockEC2APIMockRecorder) ImportClientVpnClientCertificateRevocationListRequest(arg0 interface{}) *gomock.Call { 15795 mr.mock.ctrl.T.Helper() 15796 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportClientVpnClientCertificateRevocationListRequest", reflect.TypeOf((*MockEC2API)(nil).ImportClientVpnClientCertificateRevocationListRequest), arg0) 15797 } 15798 15799 // ImportImage mocks base method 15800 func (m *MockEC2API) ImportImage(arg0 *ec2.ImportImageInput) (*ec2.ImportImageOutput, error) { 15801 m.ctrl.T.Helper() 15802 ret := m.ctrl.Call(m, "ImportImage", arg0) 15803 ret0, _ := ret[0].(*ec2.ImportImageOutput) 15804 ret1, _ := ret[1].(error) 15805 return ret0, ret1 15806 } 15807 15808 // ImportImage indicates an expected call of ImportImage 15809 func (mr *MockEC2APIMockRecorder) ImportImage(arg0 interface{}) *gomock.Call { 15810 mr.mock.ctrl.T.Helper() 15811 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImage", reflect.TypeOf((*MockEC2API)(nil).ImportImage), arg0) 15812 } 15813 15814 // ImportImageWithContext mocks base method 15815 func (m *MockEC2API) ImportImageWithContext(arg0 aws.Context, arg1 *ec2.ImportImageInput, arg2 ...request.Option) (*ec2.ImportImageOutput, error) { 15816 m.ctrl.T.Helper() 15817 varargs := []interface{}{arg0, arg1} 15818 for _, a := range arg2 { 15819 varargs = append(varargs, a) 15820 } 15821 ret := m.ctrl.Call(m, "ImportImageWithContext", varargs...) 15822 ret0, _ := ret[0].(*ec2.ImportImageOutput) 15823 ret1, _ := ret[1].(error) 15824 return ret0, ret1 15825 } 15826 15827 // ImportImageWithContext indicates an expected call of ImportImageWithContext 15828 func (mr *MockEC2APIMockRecorder) ImportImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15829 mr.mock.ctrl.T.Helper() 15830 varargs := append([]interface{}{arg0, arg1}, arg2...) 15831 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImageWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportImageWithContext), varargs...) 15832 } 15833 15834 // ImportImageRequest mocks base method 15835 func (m *MockEC2API) ImportImageRequest(arg0 *ec2.ImportImageInput) (*request.Request, *ec2.ImportImageOutput) { 15836 m.ctrl.T.Helper() 15837 ret := m.ctrl.Call(m, "ImportImageRequest", arg0) 15838 ret0, _ := ret[0].(*request.Request) 15839 ret1, _ := ret[1].(*ec2.ImportImageOutput) 15840 return ret0, ret1 15841 } 15842 15843 // ImportImageRequest indicates an expected call of ImportImageRequest 15844 func (mr *MockEC2APIMockRecorder) ImportImageRequest(arg0 interface{}) *gomock.Call { 15845 mr.mock.ctrl.T.Helper() 15846 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportImageRequest", reflect.TypeOf((*MockEC2API)(nil).ImportImageRequest), arg0) 15847 } 15848 15849 // ImportInstance mocks base method 15850 func (m *MockEC2API) ImportInstance(arg0 *ec2.ImportInstanceInput) (*ec2.ImportInstanceOutput, error) { 15851 m.ctrl.T.Helper() 15852 ret := m.ctrl.Call(m, "ImportInstance", arg0) 15853 ret0, _ := ret[0].(*ec2.ImportInstanceOutput) 15854 ret1, _ := ret[1].(error) 15855 return ret0, ret1 15856 } 15857 15858 // ImportInstance indicates an expected call of ImportInstance 15859 func (mr *MockEC2APIMockRecorder) ImportInstance(arg0 interface{}) *gomock.Call { 15860 mr.mock.ctrl.T.Helper() 15861 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstance", reflect.TypeOf((*MockEC2API)(nil).ImportInstance), arg0) 15862 } 15863 15864 // ImportInstanceWithContext mocks base method 15865 func (m *MockEC2API) ImportInstanceWithContext(arg0 aws.Context, arg1 *ec2.ImportInstanceInput, arg2 ...request.Option) (*ec2.ImportInstanceOutput, error) { 15866 m.ctrl.T.Helper() 15867 varargs := []interface{}{arg0, arg1} 15868 for _, a := range arg2 { 15869 varargs = append(varargs, a) 15870 } 15871 ret := m.ctrl.Call(m, "ImportInstanceWithContext", varargs...) 15872 ret0, _ := ret[0].(*ec2.ImportInstanceOutput) 15873 ret1, _ := ret[1].(error) 15874 return ret0, ret1 15875 } 15876 15877 // ImportInstanceWithContext indicates an expected call of ImportInstanceWithContext 15878 func (mr *MockEC2APIMockRecorder) ImportInstanceWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15879 mr.mock.ctrl.T.Helper() 15880 varargs := append([]interface{}{arg0, arg1}, arg2...) 15881 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstanceWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportInstanceWithContext), varargs...) 15882 } 15883 15884 // ImportInstanceRequest mocks base method 15885 func (m *MockEC2API) ImportInstanceRequest(arg0 *ec2.ImportInstanceInput) (*request.Request, *ec2.ImportInstanceOutput) { 15886 m.ctrl.T.Helper() 15887 ret := m.ctrl.Call(m, "ImportInstanceRequest", arg0) 15888 ret0, _ := ret[0].(*request.Request) 15889 ret1, _ := ret[1].(*ec2.ImportInstanceOutput) 15890 return ret0, ret1 15891 } 15892 15893 // ImportInstanceRequest indicates an expected call of ImportInstanceRequest 15894 func (mr *MockEC2APIMockRecorder) ImportInstanceRequest(arg0 interface{}) *gomock.Call { 15895 mr.mock.ctrl.T.Helper() 15896 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportInstanceRequest", reflect.TypeOf((*MockEC2API)(nil).ImportInstanceRequest), arg0) 15897 } 15898 15899 // ImportKeyPair mocks base method 15900 func (m *MockEC2API) ImportKeyPair(arg0 *ec2.ImportKeyPairInput) (*ec2.ImportKeyPairOutput, error) { 15901 m.ctrl.T.Helper() 15902 ret := m.ctrl.Call(m, "ImportKeyPair", arg0) 15903 ret0, _ := ret[0].(*ec2.ImportKeyPairOutput) 15904 ret1, _ := ret[1].(error) 15905 return ret0, ret1 15906 } 15907 15908 // ImportKeyPair indicates an expected call of ImportKeyPair 15909 func (mr *MockEC2APIMockRecorder) ImportKeyPair(arg0 interface{}) *gomock.Call { 15910 mr.mock.ctrl.T.Helper() 15911 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPair", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPair), arg0) 15912 } 15913 15914 // ImportKeyPairWithContext mocks base method 15915 func (m *MockEC2API) ImportKeyPairWithContext(arg0 aws.Context, arg1 *ec2.ImportKeyPairInput, arg2 ...request.Option) (*ec2.ImportKeyPairOutput, error) { 15916 m.ctrl.T.Helper() 15917 varargs := []interface{}{arg0, arg1} 15918 for _, a := range arg2 { 15919 varargs = append(varargs, a) 15920 } 15921 ret := m.ctrl.Call(m, "ImportKeyPairWithContext", varargs...) 15922 ret0, _ := ret[0].(*ec2.ImportKeyPairOutput) 15923 ret1, _ := ret[1].(error) 15924 return ret0, ret1 15925 } 15926 15927 // ImportKeyPairWithContext indicates an expected call of ImportKeyPairWithContext 15928 func (mr *MockEC2APIMockRecorder) ImportKeyPairWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15929 mr.mock.ctrl.T.Helper() 15930 varargs := append([]interface{}{arg0, arg1}, arg2...) 15931 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPairWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPairWithContext), varargs...) 15932 } 15933 15934 // ImportKeyPairRequest mocks base method 15935 func (m *MockEC2API) ImportKeyPairRequest(arg0 *ec2.ImportKeyPairInput) (*request.Request, *ec2.ImportKeyPairOutput) { 15936 m.ctrl.T.Helper() 15937 ret := m.ctrl.Call(m, "ImportKeyPairRequest", arg0) 15938 ret0, _ := ret[0].(*request.Request) 15939 ret1, _ := ret[1].(*ec2.ImportKeyPairOutput) 15940 return ret0, ret1 15941 } 15942 15943 // ImportKeyPairRequest indicates an expected call of ImportKeyPairRequest 15944 func (mr *MockEC2APIMockRecorder) ImportKeyPairRequest(arg0 interface{}) *gomock.Call { 15945 mr.mock.ctrl.T.Helper() 15946 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportKeyPairRequest", reflect.TypeOf((*MockEC2API)(nil).ImportKeyPairRequest), arg0) 15947 } 15948 15949 // ImportSnapshot mocks base method 15950 func (m *MockEC2API) ImportSnapshot(arg0 *ec2.ImportSnapshotInput) (*ec2.ImportSnapshotOutput, error) { 15951 m.ctrl.T.Helper() 15952 ret := m.ctrl.Call(m, "ImportSnapshot", arg0) 15953 ret0, _ := ret[0].(*ec2.ImportSnapshotOutput) 15954 ret1, _ := ret[1].(error) 15955 return ret0, ret1 15956 } 15957 15958 // ImportSnapshot indicates an expected call of ImportSnapshot 15959 func (mr *MockEC2APIMockRecorder) ImportSnapshot(arg0 interface{}) *gomock.Call { 15960 mr.mock.ctrl.T.Helper() 15961 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshot", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshot), arg0) 15962 } 15963 15964 // ImportSnapshotWithContext mocks base method 15965 func (m *MockEC2API) ImportSnapshotWithContext(arg0 aws.Context, arg1 *ec2.ImportSnapshotInput, arg2 ...request.Option) (*ec2.ImportSnapshotOutput, error) { 15966 m.ctrl.T.Helper() 15967 varargs := []interface{}{arg0, arg1} 15968 for _, a := range arg2 { 15969 varargs = append(varargs, a) 15970 } 15971 ret := m.ctrl.Call(m, "ImportSnapshotWithContext", varargs...) 15972 ret0, _ := ret[0].(*ec2.ImportSnapshotOutput) 15973 ret1, _ := ret[1].(error) 15974 return ret0, ret1 15975 } 15976 15977 // ImportSnapshotWithContext indicates an expected call of ImportSnapshotWithContext 15978 func (mr *MockEC2APIMockRecorder) ImportSnapshotWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 15979 mr.mock.ctrl.T.Helper() 15980 varargs := append([]interface{}{arg0, arg1}, arg2...) 15981 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshotWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshotWithContext), varargs...) 15982 } 15983 15984 // ImportSnapshotRequest mocks base method 15985 func (m *MockEC2API) ImportSnapshotRequest(arg0 *ec2.ImportSnapshotInput) (*request.Request, *ec2.ImportSnapshotOutput) { 15986 m.ctrl.T.Helper() 15987 ret := m.ctrl.Call(m, "ImportSnapshotRequest", arg0) 15988 ret0, _ := ret[0].(*request.Request) 15989 ret1, _ := ret[1].(*ec2.ImportSnapshotOutput) 15990 return ret0, ret1 15991 } 15992 15993 // ImportSnapshotRequest indicates an expected call of ImportSnapshotRequest 15994 func (mr *MockEC2APIMockRecorder) ImportSnapshotRequest(arg0 interface{}) *gomock.Call { 15995 mr.mock.ctrl.T.Helper() 15996 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportSnapshotRequest", reflect.TypeOf((*MockEC2API)(nil).ImportSnapshotRequest), arg0) 15997 } 15998 15999 // ImportVolume mocks base method 16000 func (m *MockEC2API) ImportVolume(arg0 *ec2.ImportVolumeInput) (*ec2.ImportVolumeOutput, error) { 16001 m.ctrl.T.Helper() 16002 ret := m.ctrl.Call(m, "ImportVolume", arg0) 16003 ret0, _ := ret[0].(*ec2.ImportVolumeOutput) 16004 ret1, _ := ret[1].(error) 16005 return ret0, ret1 16006 } 16007 16008 // ImportVolume indicates an expected call of ImportVolume 16009 func (mr *MockEC2APIMockRecorder) ImportVolume(arg0 interface{}) *gomock.Call { 16010 mr.mock.ctrl.T.Helper() 16011 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolume", reflect.TypeOf((*MockEC2API)(nil).ImportVolume), arg0) 16012 } 16013 16014 // ImportVolumeWithContext mocks base method 16015 func (m *MockEC2API) ImportVolumeWithContext(arg0 aws.Context, arg1 *ec2.ImportVolumeInput, arg2 ...request.Option) (*ec2.ImportVolumeOutput, error) { 16016 m.ctrl.T.Helper() 16017 varargs := []interface{}{arg0, arg1} 16018 for _, a := range arg2 { 16019 varargs = append(varargs, a) 16020 } 16021 ret := m.ctrl.Call(m, "ImportVolumeWithContext", varargs...) 16022 ret0, _ := ret[0].(*ec2.ImportVolumeOutput) 16023 ret1, _ := ret[1].(error) 16024 return ret0, ret1 16025 } 16026 16027 // ImportVolumeWithContext indicates an expected call of ImportVolumeWithContext 16028 func (mr *MockEC2APIMockRecorder) ImportVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16029 mr.mock.ctrl.T.Helper() 16030 varargs := append([]interface{}{arg0, arg1}, arg2...) 16031 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeWithContext), varargs...) 16032 } 16033 16034 // ImportVolumeRequest mocks base method 16035 func (m *MockEC2API) ImportVolumeRequest(arg0 *ec2.ImportVolumeInput) (*request.Request, *ec2.ImportVolumeOutput) { 16036 m.ctrl.T.Helper() 16037 ret := m.ctrl.Call(m, "ImportVolumeRequest", arg0) 16038 ret0, _ := ret[0].(*request.Request) 16039 ret1, _ := ret[1].(*ec2.ImportVolumeOutput) 16040 return ret0, ret1 16041 } 16042 16043 // ImportVolumeRequest indicates an expected call of ImportVolumeRequest 16044 func (mr *MockEC2APIMockRecorder) ImportVolumeRequest(arg0 interface{}) *gomock.Call { 16045 mr.mock.ctrl.T.Helper() 16046 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ImportVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ImportVolumeRequest), arg0) 16047 } 16048 16049 // ModifyCapacityReservation mocks base method 16050 func (m *MockEC2API) ModifyCapacityReservation(arg0 *ec2.ModifyCapacityReservationInput) (*ec2.ModifyCapacityReservationOutput, error) { 16051 m.ctrl.T.Helper() 16052 ret := m.ctrl.Call(m, "ModifyCapacityReservation", arg0) 16053 ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput) 16054 ret1, _ := ret[1].(error) 16055 return ret0, ret1 16056 } 16057 16058 // ModifyCapacityReservation indicates an expected call of ModifyCapacityReservation 16059 func (mr *MockEC2APIMockRecorder) ModifyCapacityReservation(arg0 interface{}) *gomock.Call { 16060 mr.mock.ctrl.T.Helper() 16061 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservation", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservation), arg0) 16062 } 16063 16064 // ModifyCapacityReservationWithContext mocks base method 16065 func (m *MockEC2API) ModifyCapacityReservationWithContext(arg0 aws.Context, arg1 *ec2.ModifyCapacityReservationInput, arg2 ...request.Option) (*ec2.ModifyCapacityReservationOutput, error) { 16066 m.ctrl.T.Helper() 16067 varargs := []interface{}{arg0, arg1} 16068 for _, a := range arg2 { 16069 varargs = append(varargs, a) 16070 } 16071 ret := m.ctrl.Call(m, "ModifyCapacityReservationWithContext", varargs...) 16072 ret0, _ := ret[0].(*ec2.ModifyCapacityReservationOutput) 16073 ret1, _ := ret[1].(error) 16074 return ret0, ret1 16075 } 16076 16077 // ModifyCapacityReservationWithContext indicates an expected call of ModifyCapacityReservationWithContext 16078 func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16079 mr.mock.ctrl.T.Helper() 16080 varargs := append([]interface{}{arg0, arg1}, arg2...) 16081 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationWithContext), varargs...) 16082 } 16083 16084 // ModifyCapacityReservationRequest mocks base method 16085 func (m *MockEC2API) ModifyCapacityReservationRequest(arg0 *ec2.ModifyCapacityReservationInput) (*request.Request, *ec2.ModifyCapacityReservationOutput) { 16086 m.ctrl.T.Helper() 16087 ret := m.ctrl.Call(m, "ModifyCapacityReservationRequest", arg0) 16088 ret0, _ := ret[0].(*request.Request) 16089 ret1, _ := ret[1].(*ec2.ModifyCapacityReservationOutput) 16090 return ret0, ret1 16091 } 16092 16093 // ModifyCapacityReservationRequest indicates an expected call of ModifyCapacityReservationRequest 16094 func (mr *MockEC2APIMockRecorder) ModifyCapacityReservationRequest(arg0 interface{}) *gomock.Call { 16095 mr.mock.ctrl.T.Helper() 16096 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyCapacityReservationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyCapacityReservationRequest), arg0) 16097 } 16098 16099 // ModifyClientVpnEndpoint mocks base method 16100 func (m *MockEC2API) ModifyClientVpnEndpoint(arg0 *ec2.ModifyClientVpnEndpointInput) (*ec2.ModifyClientVpnEndpointOutput, error) { 16101 m.ctrl.T.Helper() 16102 ret := m.ctrl.Call(m, "ModifyClientVpnEndpoint", arg0) 16103 ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput) 16104 ret1, _ := ret[1].(error) 16105 return ret0, ret1 16106 } 16107 16108 // ModifyClientVpnEndpoint indicates an expected call of ModifyClientVpnEndpoint 16109 func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpoint(arg0 interface{}) *gomock.Call { 16110 mr.mock.ctrl.T.Helper() 16111 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpoint), arg0) 16112 } 16113 16114 // ModifyClientVpnEndpointWithContext mocks base method 16115 func (m *MockEC2API) ModifyClientVpnEndpointWithContext(arg0 aws.Context, arg1 *ec2.ModifyClientVpnEndpointInput, arg2 ...request.Option) (*ec2.ModifyClientVpnEndpointOutput, error) { 16116 m.ctrl.T.Helper() 16117 varargs := []interface{}{arg0, arg1} 16118 for _, a := range arg2 { 16119 varargs = append(varargs, a) 16120 } 16121 ret := m.ctrl.Call(m, "ModifyClientVpnEndpointWithContext", varargs...) 16122 ret0, _ := ret[0].(*ec2.ModifyClientVpnEndpointOutput) 16123 ret1, _ := ret[1].(error) 16124 return ret0, ret1 16125 } 16126 16127 // ModifyClientVpnEndpointWithContext indicates an expected call of ModifyClientVpnEndpointWithContext 16128 func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16129 mr.mock.ctrl.T.Helper() 16130 varargs := append([]interface{}{arg0, arg1}, arg2...) 16131 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointWithContext), varargs...) 16132 } 16133 16134 // ModifyClientVpnEndpointRequest mocks base method 16135 func (m *MockEC2API) ModifyClientVpnEndpointRequest(arg0 *ec2.ModifyClientVpnEndpointInput) (*request.Request, *ec2.ModifyClientVpnEndpointOutput) { 16136 m.ctrl.T.Helper() 16137 ret := m.ctrl.Call(m, "ModifyClientVpnEndpointRequest", arg0) 16138 ret0, _ := ret[0].(*request.Request) 16139 ret1, _ := ret[1].(*ec2.ModifyClientVpnEndpointOutput) 16140 return ret0, ret1 16141 } 16142 16143 // ModifyClientVpnEndpointRequest indicates an expected call of ModifyClientVpnEndpointRequest 16144 func (mr *MockEC2APIMockRecorder) ModifyClientVpnEndpointRequest(arg0 interface{}) *gomock.Call { 16145 mr.mock.ctrl.T.Helper() 16146 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyClientVpnEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyClientVpnEndpointRequest), arg0) 16147 } 16148 16149 // ModifyEbsDefaultKmsKeyId mocks base method 16150 func (m *MockEC2API) ModifyEbsDefaultKmsKeyId(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) { 16151 m.ctrl.T.Helper() 16152 ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyId", arg0) 16153 ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) 16154 ret1, _ := ret[1].(error) 16155 return ret0, ret1 16156 } 16157 16158 // ModifyEbsDefaultKmsKeyId indicates an expected call of ModifyEbsDefaultKmsKeyId 16159 func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { 16160 mr.mock.ctrl.T.Helper() 16161 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyId), arg0) 16162 } 16163 16164 // ModifyEbsDefaultKmsKeyIdWithContext mocks base method 16165 func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdWithContext(arg0 aws.Context, arg1 *ec2.ModifyEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ModifyEbsDefaultKmsKeyIdOutput, error) { 16166 m.ctrl.T.Helper() 16167 varargs := []interface{}{arg0, arg1} 16168 for _, a := range arg2 { 16169 varargs = append(varargs, a) 16170 } 16171 ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdWithContext", varargs...) 16172 ret0, _ := ret[0].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) 16173 ret1, _ := ret[1].(error) 16174 return ret0, ret1 16175 } 16176 16177 // ModifyEbsDefaultKmsKeyIdWithContext indicates an expected call of ModifyEbsDefaultKmsKeyIdWithContext 16178 func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16179 mr.mock.ctrl.T.Helper() 16180 varargs := append([]interface{}{arg0, arg1}, arg2...) 16181 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdWithContext), varargs...) 16182 } 16183 16184 // ModifyEbsDefaultKmsKeyIdRequest mocks base method 16185 func (m *MockEC2API) ModifyEbsDefaultKmsKeyIdRequest(arg0 *ec2.ModifyEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ModifyEbsDefaultKmsKeyIdOutput) { 16186 m.ctrl.T.Helper() 16187 ret := m.ctrl.Call(m, "ModifyEbsDefaultKmsKeyIdRequest", arg0) 16188 ret0, _ := ret[0].(*request.Request) 16189 ret1, _ := ret[1].(*ec2.ModifyEbsDefaultKmsKeyIdOutput) 16190 return ret0, ret1 16191 } 16192 16193 // ModifyEbsDefaultKmsKeyIdRequest indicates an expected call of ModifyEbsDefaultKmsKeyIdRequest 16194 func (mr *MockEC2APIMockRecorder) ModifyEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { 16195 mr.mock.ctrl.T.Helper() 16196 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyEbsDefaultKmsKeyIdRequest), arg0) 16197 } 16198 16199 // ModifyFleet mocks base method 16200 func (m *MockEC2API) ModifyFleet(arg0 *ec2.ModifyFleetInput) (*ec2.ModifyFleetOutput, error) { 16201 m.ctrl.T.Helper() 16202 ret := m.ctrl.Call(m, "ModifyFleet", arg0) 16203 ret0, _ := ret[0].(*ec2.ModifyFleetOutput) 16204 ret1, _ := ret[1].(error) 16205 return ret0, ret1 16206 } 16207 16208 // ModifyFleet indicates an expected call of ModifyFleet 16209 func (mr *MockEC2APIMockRecorder) ModifyFleet(arg0 interface{}) *gomock.Call { 16210 mr.mock.ctrl.T.Helper() 16211 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleet", reflect.TypeOf((*MockEC2API)(nil).ModifyFleet), arg0) 16212 } 16213 16214 // ModifyFleetWithContext mocks base method 16215 func (m *MockEC2API) ModifyFleetWithContext(arg0 aws.Context, arg1 *ec2.ModifyFleetInput, arg2 ...request.Option) (*ec2.ModifyFleetOutput, error) { 16216 m.ctrl.T.Helper() 16217 varargs := []interface{}{arg0, arg1} 16218 for _, a := range arg2 { 16219 varargs = append(varargs, a) 16220 } 16221 ret := m.ctrl.Call(m, "ModifyFleetWithContext", varargs...) 16222 ret0, _ := ret[0].(*ec2.ModifyFleetOutput) 16223 ret1, _ := ret[1].(error) 16224 return ret0, ret1 16225 } 16226 16227 // ModifyFleetWithContext indicates an expected call of ModifyFleetWithContext 16228 func (mr *MockEC2APIMockRecorder) ModifyFleetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16229 mr.mock.ctrl.T.Helper() 16230 varargs := append([]interface{}{arg0, arg1}, arg2...) 16231 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyFleetWithContext), varargs...) 16232 } 16233 16234 // ModifyFleetRequest mocks base method 16235 func (m *MockEC2API) ModifyFleetRequest(arg0 *ec2.ModifyFleetInput) (*request.Request, *ec2.ModifyFleetOutput) { 16236 m.ctrl.T.Helper() 16237 ret := m.ctrl.Call(m, "ModifyFleetRequest", arg0) 16238 ret0, _ := ret[0].(*request.Request) 16239 ret1, _ := ret[1].(*ec2.ModifyFleetOutput) 16240 return ret0, ret1 16241 } 16242 16243 // ModifyFleetRequest indicates an expected call of ModifyFleetRequest 16244 func (mr *MockEC2APIMockRecorder) ModifyFleetRequest(arg0 interface{}) *gomock.Call { 16245 mr.mock.ctrl.T.Helper() 16246 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFleetRequest), arg0) 16247 } 16248 16249 // ModifyFpgaImageAttribute mocks base method 16250 func (m *MockEC2API) ModifyFpgaImageAttribute(arg0 *ec2.ModifyFpgaImageAttributeInput) (*ec2.ModifyFpgaImageAttributeOutput, error) { 16251 m.ctrl.T.Helper() 16252 ret := m.ctrl.Call(m, "ModifyFpgaImageAttribute", arg0) 16253 ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput) 16254 ret1, _ := ret[1].(error) 16255 return ret0, ret1 16256 } 16257 16258 // ModifyFpgaImageAttribute indicates an expected call of ModifyFpgaImageAttribute 16259 func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttribute(arg0 interface{}) *gomock.Call { 16260 mr.mock.ctrl.T.Helper() 16261 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttribute), arg0) 16262 } 16263 16264 // ModifyFpgaImageAttributeWithContext mocks base method 16265 func (m *MockEC2API) ModifyFpgaImageAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifyFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyFpgaImageAttributeOutput, error) { 16266 m.ctrl.T.Helper() 16267 varargs := []interface{}{arg0, arg1} 16268 for _, a := range arg2 { 16269 varargs = append(varargs, a) 16270 } 16271 ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeWithContext", varargs...) 16272 ret0, _ := ret[0].(*ec2.ModifyFpgaImageAttributeOutput) 16273 ret1, _ := ret[1].(error) 16274 return ret0, ret1 16275 } 16276 16277 // ModifyFpgaImageAttributeWithContext indicates an expected call of ModifyFpgaImageAttributeWithContext 16278 func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16279 mr.mock.ctrl.T.Helper() 16280 varargs := append([]interface{}{arg0, arg1}, arg2...) 16281 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttributeWithContext), varargs...) 16282 } 16283 16284 // ModifyFpgaImageAttributeRequest mocks base method 16285 func (m *MockEC2API) ModifyFpgaImageAttributeRequest(arg0 *ec2.ModifyFpgaImageAttributeInput) (*request.Request, *ec2.ModifyFpgaImageAttributeOutput) { 16286 m.ctrl.T.Helper() 16287 ret := m.ctrl.Call(m, "ModifyFpgaImageAttributeRequest", arg0) 16288 ret0, _ := ret[0].(*request.Request) 16289 ret1, _ := ret[1].(*ec2.ModifyFpgaImageAttributeOutput) 16290 return ret0, ret1 16291 } 16292 16293 // ModifyFpgaImageAttributeRequest indicates an expected call of ModifyFpgaImageAttributeRequest 16294 func (mr *MockEC2APIMockRecorder) ModifyFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { 16295 mr.mock.ctrl.T.Helper() 16296 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyFpgaImageAttributeRequest), arg0) 16297 } 16298 16299 // ModifyHosts mocks base method 16300 func (m *MockEC2API) ModifyHosts(arg0 *ec2.ModifyHostsInput) (*ec2.ModifyHostsOutput, error) { 16301 m.ctrl.T.Helper() 16302 ret := m.ctrl.Call(m, "ModifyHosts", arg0) 16303 ret0, _ := ret[0].(*ec2.ModifyHostsOutput) 16304 ret1, _ := ret[1].(error) 16305 return ret0, ret1 16306 } 16307 16308 // ModifyHosts indicates an expected call of ModifyHosts 16309 func (mr *MockEC2APIMockRecorder) ModifyHosts(arg0 interface{}) *gomock.Call { 16310 mr.mock.ctrl.T.Helper() 16311 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHosts", reflect.TypeOf((*MockEC2API)(nil).ModifyHosts), arg0) 16312 } 16313 16314 // ModifyHostsWithContext mocks base method 16315 func (m *MockEC2API) ModifyHostsWithContext(arg0 aws.Context, arg1 *ec2.ModifyHostsInput, arg2 ...request.Option) (*ec2.ModifyHostsOutput, error) { 16316 m.ctrl.T.Helper() 16317 varargs := []interface{}{arg0, arg1} 16318 for _, a := range arg2 { 16319 varargs = append(varargs, a) 16320 } 16321 ret := m.ctrl.Call(m, "ModifyHostsWithContext", varargs...) 16322 ret0, _ := ret[0].(*ec2.ModifyHostsOutput) 16323 ret1, _ := ret[1].(error) 16324 return ret0, ret1 16325 } 16326 16327 // ModifyHostsWithContext indicates an expected call of ModifyHostsWithContext 16328 func (mr *MockEC2APIMockRecorder) ModifyHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16329 mr.mock.ctrl.T.Helper() 16330 varargs := append([]interface{}{arg0, arg1}, arg2...) 16331 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyHostsWithContext), varargs...) 16332 } 16333 16334 // ModifyHostsRequest mocks base method 16335 func (m *MockEC2API) ModifyHostsRequest(arg0 *ec2.ModifyHostsInput) (*request.Request, *ec2.ModifyHostsOutput) { 16336 m.ctrl.T.Helper() 16337 ret := m.ctrl.Call(m, "ModifyHostsRequest", arg0) 16338 ret0, _ := ret[0].(*request.Request) 16339 ret1, _ := ret[1].(*ec2.ModifyHostsOutput) 16340 return ret0, ret1 16341 } 16342 16343 // ModifyHostsRequest indicates an expected call of ModifyHostsRequest 16344 func (mr *MockEC2APIMockRecorder) ModifyHostsRequest(arg0 interface{}) *gomock.Call { 16345 mr.mock.ctrl.T.Helper() 16346 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyHostsRequest), arg0) 16347 } 16348 16349 // ModifyIdFormat mocks base method 16350 func (m *MockEC2API) ModifyIdFormat(arg0 *ec2.ModifyIdFormatInput) (*ec2.ModifyIdFormatOutput, error) { 16351 m.ctrl.T.Helper() 16352 ret := m.ctrl.Call(m, "ModifyIdFormat", arg0) 16353 ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput) 16354 ret1, _ := ret[1].(error) 16355 return ret0, ret1 16356 } 16357 16358 // ModifyIdFormat indicates an expected call of ModifyIdFormat 16359 func (mr *MockEC2APIMockRecorder) ModifyIdFormat(arg0 interface{}) *gomock.Call { 16360 mr.mock.ctrl.T.Helper() 16361 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormat), arg0) 16362 } 16363 16364 // ModifyIdFormatWithContext mocks base method 16365 func (m *MockEC2API) ModifyIdFormatWithContext(arg0 aws.Context, arg1 *ec2.ModifyIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdFormatOutput, error) { 16366 m.ctrl.T.Helper() 16367 varargs := []interface{}{arg0, arg1} 16368 for _, a := range arg2 { 16369 varargs = append(varargs, a) 16370 } 16371 ret := m.ctrl.Call(m, "ModifyIdFormatWithContext", varargs...) 16372 ret0, _ := ret[0].(*ec2.ModifyIdFormatOutput) 16373 ret1, _ := ret[1].(error) 16374 return ret0, ret1 16375 } 16376 16377 // ModifyIdFormatWithContext indicates an expected call of ModifyIdFormatWithContext 16378 func (mr *MockEC2APIMockRecorder) ModifyIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16379 mr.mock.ctrl.T.Helper() 16380 varargs := append([]interface{}{arg0, arg1}, arg2...) 16381 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormatWithContext), varargs...) 16382 } 16383 16384 // ModifyIdFormatRequest mocks base method 16385 func (m *MockEC2API) ModifyIdFormatRequest(arg0 *ec2.ModifyIdFormatInput) (*request.Request, *ec2.ModifyIdFormatOutput) { 16386 m.ctrl.T.Helper() 16387 ret := m.ctrl.Call(m, "ModifyIdFormatRequest", arg0) 16388 ret0, _ := ret[0].(*request.Request) 16389 ret1, _ := ret[1].(*ec2.ModifyIdFormatOutput) 16390 return ret0, ret1 16391 } 16392 16393 // ModifyIdFormatRequest indicates an expected call of ModifyIdFormatRequest 16394 func (mr *MockEC2APIMockRecorder) ModifyIdFormatRequest(arg0 interface{}) *gomock.Call { 16395 mr.mock.ctrl.T.Helper() 16396 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdFormatRequest), arg0) 16397 } 16398 16399 // ModifyIdentityIdFormat mocks base method 16400 func (m *MockEC2API) ModifyIdentityIdFormat(arg0 *ec2.ModifyIdentityIdFormatInput) (*ec2.ModifyIdentityIdFormatOutput, error) { 16401 m.ctrl.T.Helper() 16402 ret := m.ctrl.Call(m, "ModifyIdentityIdFormat", arg0) 16403 ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput) 16404 ret1, _ := ret[1].(error) 16405 return ret0, ret1 16406 } 16407 16408 // ModifyIdentityIdFormat indicates an expected call of ModifyIdentityIdFormat 16409 func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormat(arg0 interface{}) *gomock.Call { 16410 mr.mock.ctrl.T.Helper() 16411 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormat", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormat), arg0) 16412 } 16413 16414 // ModifyIdentityIdFormatWithContext mocks base method 16415 func (m *MockEC2API) ModifyIdentityIdFormatWithContext(arg0 aws.Context, arg1 *ec2.ModifyIdentityIdFormatInput, arg2 ...request.Option) (*ec2.ModifyIdentityIdFormatOutput, error) { 16416 m.ctrl.T.Helper() 16417 varargs := []interface{}{arg0, arg1} 16418 for _, a := range arg2 { 16419 varargs = append(varargs, a) 16420 } 16421 ret := m.ctrl.Call(m, "ModifyIdentityIdFormatWithContext", varargs...) 16422 ret0, _ := ret[0].(*ec2.ModifyIdentityIdFormatOutput) 16423 ret1, _ := ret[1].(error) 16424 return ret0, ret1 16425 } 16426 16427 // ModifyIdentityIdFormatWithContext indicates an expected call of ModifyIdentityIdFormatWithContext 16428 func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormatWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16429 mr.mock.ctrl.T.Helper() 16430 varargs := append([]interface{}{arg0, arg1}, arg2...) 16431 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormatWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormatWithContext), varargs...) 16432 } 16433 16434 // ModifyIdentityIdFormatRequest mocks base method 16435 func (m *MockEC2API) ModifyIdentityIdFormatRequest(arg0 *ec2.ModifyIdentityIdFormatInput) (*request.Request, *ec2.ModifyIdentityIdFormatOutput) { 16436 m.ctrl.T.Helper() 16437 ret := m.ctrl.Call(m, "ModifyIdentityIdFormatRequest", arg0) 16438 ret0, _ := ret[0].(*request.Request) 16439 ret1, _ := ret[1].(*ec2.ModifyIdentityIdFormatOutput) 16440 return ret0, ret1 16441 } 16442 16443 // ModifyIdentityIdFormatRequest indicates an expected call of ModifyIdentityIdFormatRequest 16444 func (mr *MockEC2APIMockRecorder) ModifyIdentityIdFormatRequest(arg0 interface{}) *gomock.Call { 16445 mr.mock.ctrl.T.Helper() 16446 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyIdentityIdFormatRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyIdentityIdFormatRequest), arg0) 16447 } 16448 16449 // ModifyImageAttribute mocks base method 16450 func (m *MockEC2API) ModifyImageAttribute(arg0 *ec2.ModifyImageAttributeInput) (*ec2.ModifyImageAttributeOutput, error) { 16451 m.ctrl.T.Helper() 16452 ret := m.ctrl.Call(m, "ModifyImageAttribute", arg0) 16453 ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput) 16454 ret1, _ := ret[1].(error) 16455 return ret0, ret1 16456 } 16457 16458 // ModifyImageAttribute indicates an expected call of ModifyImageAttribute 16459 func (mr *MockEC2APIMockRecorder) ModifyImageAttribute(arg0 interface{}) *gomock.Call { 16460 mr.mock.ctrl.T.Helper() 16461 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttribute), arg0) 16462 } 16463 16464 // ModifyImageAttributeWithContext mocks base method 16465 func (m *MockEC2API) ModifyImageAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifyImageAttributeInput, arg2 ...request.Option) (*ec2.ModifyImageAttributeOutput, error) { 16466 m.ctrl.T.Helper() 16467 varargs := []interface{}{arg0, arg1} 16468 for _, a := range arg2 { 16469 varargs = append(varargs, a) 16470 } 16471 ret := m.ctrl.Call(m, "ModifyImageAttributeWithContext", varargs...) 16472 ret0, _ := ret[0].(*ec2.ModifyImageAttributeOutput) 16473 ret1, _ := ret[1].(error) 16474 return ret0, ret1 16475 } 16476 16477 // ModifyImageAttributeWithContext indicates an expected call of ModifyImageAttributeWithContext 16478 func (mr *MockEC2APIMockRecorder) ModifyImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16479 mr.mock.ctrl.T.Helper() 16480 varargs := append([]interface{}{arg0, arg1}, arg2...) 16481 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttributeWithContext), varargs...) 16482 } 16483 16484 // ModifyImageAttributeRequest mocks base method 16485 func (m *MockEC2API) ModifyImageAttributeRequest(arg0 *ec2.ModifyImageAttributeInput) (*request.Request, *ec2.ModifyImageAttributeOutput) { 16486 m.ctrl.T.Helper() 16487 ret := m.ctrl.Call(m, "ModifyImageAttributeRequest", arg0) 16488 ret0, _ := ret[0].(*request.Request) 16489 ret1, _ := ret[1].(*ec2.ModifyImageAttributeOutput) 16490 return ret0, ret1 16491 } 16492 16493 // ModifyImageAttributeRequest indicates an expected call of ModifyImageAttributeRequest 16494 func (mr *MockEC2APIMockRecorder) ModifyImageAttributeRequest(arg0 interface{}) *gomock.Call { 16495 mr.mock.ctrl.T.Helper() 16496 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyImageAttributeRequest), arg0) 16497 } 16498 16499 // ModifyInstanceAttribute mocks base method 16500 func (m *MockEC2API) ModifyInstanceAttribute(arg0 *ec2.ModifyInstanceAttributeInput) (*ec2.ModifyInstanceAttributeOutput, error) { 16501 m.ctrl.T.Helper() 16502 ret := m.ctrl.Call(m, "ModifyInstanceAttribute", arg0) 16503 ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput) 16504 ret1, _ := ret[1].(error) 16505 return ret0, ret1 16506 } 16507 16508 // ModifyInstanceAttribute indicates an expected call of ModifyInstanceAttribute 16509 func (mr *MockEC2APIMockRecorder) ModifyInstanceAttribute(arg0 interface{}) *gomock.Call { 16510 mr.mock.ctrl.T.Helper() 16511 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttribute), arg0) 16512 } 16513 16514 // ModifyInstanceAttributeWithContext mocks base method 16515 func (m *MockEC2API) ModifyInstanceAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifyInstanceAttributeInput, arg2 ...request.Option) (*ec2.ModifyInstanceAttributeOutput, error) { 16516 m.ctrl.T.Helper() 16517 varargs := []interface{}{arg0, arg1} 16518 for _, a := range arg2 { 16519 varargs = append(varargs, a) 16520 } 16521 ret := m.ctrl.Call(m, "ModifyInstanceAttributeWithContext", varargs...) 16522 ret0, _ := ret[0].(*ec2.ModifyInstanceAttributeOutput) 16523 ret1, _ := ret[1].(error) 16524 return ret0, ret1 16525 } 16526 16527 // ModifyInstanceAttributeWithContext indicates an expected call of ModifyInstanceAttributeWithContext 16528 func (mr *MockEC2APIMockRecorder) ModifyInstanceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16529 mr.mock.ctrl.T.Helper() 16530 varargs := append([]interface{}{arg0, arg1}, arg2...) 16531 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttributeWithContext), varargs...) 16532 } 16533 16534 // ModifyInstanceAttributeRequest mocks base method 16535 func (m *MockEC2API) ModifyInstanceAttributeRequest(arg0 *ec2.ModifyInstanceAttributeInput) (*request.Request, *ec2.ModifyInstanceAttributeOutput) { 16536 m.ctrl.T.Helper() 16537 ret := m.ctrl.Call(m, "ModifyInstanceAttributeRequest", arg0) 16538 ret0, _ := ret[0].(*request.Request) 16539 ret1, _ := ret[1].(*ec2.ModifyInstanceAttributeOutput) 16540 return ret0, ret1 16541 } 16542 16543 // ModifyInstanceAttributeRequest indicates an expected call of ModifyInstanceAttributeRequest 16544 func (mr *MockEC2APIMockRecorder) ModifyInstanceAttributeRequest(arg0 interface{}) *gomock.Call { 16545 mr.mock.ctrl.T.Helper() 16546 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceAttributeRequest), arg0) 16547 } 16548 16549 // ModifyInstanceCapacityReservationAttributes mocks base method 16550 func (m *MockEC2API) ModifyInstanceCapacityReservationAttributes(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) { 16551 m.ctrl.T.Helper() 16552 ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributes", arg0) 16553 ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) 16554 ret1, _ := ret[1].(error) 16555 return ret0, ret1 16556 } 16557 16558 // ModifyInstanceCapacityReservationAttributes indicates an expected call of ModifyInstanceCapacityReservationAttributes 16559 func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributes(arg0 interface{}) *gomock.Call { 16560 mr.mock.ctrl.T.Helper() 16561 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributes", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributes), arg0) 16562 } 16563 16564 // ModifyInstanceCapacityReservationAttributesWithContext mocks base method 16565 func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesWithContext(arg0 aws.Context, arg1 *ec2.ModifyInstanceCapacityReservationAttributesInput, arg2 ...request.Option) (*ec2.ModifyInstanceCapacityReservationAttributesOutput, error) { 16566 m.ctrl.T.Helper() 16567 varargs := []interface{}{arg0, arg1} 16568 for _, a := range arg2 { 16569 varargs = append(varargs, a) 16570 } 16571 ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesWithContext", varargs...) 16572 ret0, _ := ret[0].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) 16573 ret1, _ := ret[1].(error) 16574 return ret0, ret1 16575 } 16576 16577 // ModifyInstanceCapacityReservationAttributesWithContext indicates an expected call of ModifyInstanceCapacityReservationAttributesWithContext 16578 func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16579 mr.mock.ctrl.T.Helper() 16580 varargs := append([]interface{}{arg0, arg1}, arg2...) 16581 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesWithContext), varargs...) 16582 } 16583 16584 // ModifyInstanceCapacityReservationAttributesRequest mocks base method 16585 func (m *MockEC2API) ModifyInstanceCapacityReservationAttributesRequest(arg0 *ec2.ModifyInstanceCapacityReservationAttributesInput) (*request.Request, *ec2.ModifyInstanceCapacityReservationAttributesOutput) { 16586 m.ctrl.T.Helper() 16587 ret := m.ctrl.Call(m, "ModifyInstanceCapacityReservationAttributesRequest", arg0) 16588 ret0, _ := ret[0].(*request.Request) 16589 ret1, _ := ret[1].(*ec2.ModifyInstanceCapacityReservationAttributesOutput) 16590 return ret0, ret1 16591 } 16592 16593 // ModifyInstanceCapacityReservationAttributesRequest indicates an expected call of ModifyInstanceCapacityReservationAttributesRequest 16594 func (mr *MockEC2APIMockRecorder) ModifyInstanceCapacityReservationAttributesRequest(arg0 interface{}) *gomock.Call { 16595 mr.mock.ctrl.T.Helper() 16596 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCapacityReservationAttributesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCapacityReservationAttributesRequest), arg0) 16597 } 16598 16599 // ModifyInstanceCreditSpecification mocks base method 16600 func (m *MockEC2API) ModifyInstanceCreditSpecification(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*ec2.ModifyInstanceCreditSpecificationOutput, error) { 16601 m.ctrl.T.Helper() 16602 ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecification", arg0) 16603 ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput) 16604 ret1, _ := ret[1].(error) 16605 return ret0, ret1 16606 } 16607 16608 // ModifyInstanceCreditSpecification indicates an expected call of ModifyInstanceCreditSpecification 16609 func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecification(arg0 interface{}) *gomock.Call { 16610 mr.mock.ctrl.T.Helper() 16611 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecification", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecification), arg0) 16612 } 16613 16614 // ModifyInstanceCreditSpecificationWithContext mocks base method 16615 func (m *MockEC2API) ModifyInstanceCreditSpecificationWithContext(arg0 aws.Context, arg1 *ec2.ModifyInstanceCreditSpecificationInput, arg2 ...request.Option) (*ec2.ModifyInstanceCreditSpecificationOutput, error) { 16616 m.ctrl.T.Helper() 16617 varargs := []interface{}{arg0, arg1} 16618 for _, a := range arg2 { 16619 varargs = append(varargs, a) 16620 } 16621 ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationWithContext", varargs...) 16622 ret0, _ := ret[0].(*ec2.ModifyInstanceCreditSpecificationOutput) 16623 ret1, _ := ret[1].(error) 16624 return ret0, ret1 16625 } 16626 16627 // ModifyInstanceCreditSpecificationWithContext indicates an expected call of ModifyInstanceCreditSpecificationWithContext 16628 func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16629 mr.mock.ctrl.T.Helper() 16630 varargs := append([]interface{}{arg0, arg1}, arg2...) 16631 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecificationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecificationWithContext), varargs...) 16632 } 16633 16634 // ModifyInstanceCreditSpecificationRequest mocks base method 16635 func (m *MockEC2API) ModifyInstanceCreditSpecificationRequest(arg0 *ec2.ModifyInstanceCreditSpecificationInput) (*request.Request, *ec2.ModifyInstanceCreditSpecificationOutput) { 16636 m.ctrl.T.Helper() 16637 ret := m.ctrl.Call(m, "ModifyInstanceCreditSpecificationRequest", arg0) 16638 ret0, _ := ret[0].(*request.Request) 16639 ret1, _ := ret[1].(*ec2.ModifyInstanceCreditSpecificationOutput) 16640 return ret0, ret1 16641 } 16642 16643 // ModifyInstanceCreditSpecificationRequest indicates an expected call of ModifyInstanceCreditSpecificationRequest 16644 func (mr *MockEC2APIMockRecorder) ModifyInstanceCreditSpecificationRequest(arg0 interface{}) *gomock.Call { 16645 mr.mock.ctrl.T.Helper() 16646 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceCreditSpecificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceCreditSpecificationRequest), arg0) 16647 } 16648 16649 // ModifyInstanceEventStartTime mocks base method 16650 func (m *MockEC2API) ModifyInstanceEventStartTime(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*ec2.ModifyInstanceEventStartTimeOutput, error) { 16651 m.ctrl.T.Helper() 16652 ret := m.ctrl.Call(m, "ModifyInstanceEventStartTime", arg0) 16653 ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput) 16654 ret1, _ := ret[1].(error) 16655 return ret0, ret1 16656 } 16657 16658 // ModifyInstanceEventStartTime indicates an expected call of ModifyInstanceEventStartTime 16659 func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTime(arg0 interface{}) *gomock.Call { 16660 mr.mock.ctrl.T.Helper() 16661 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTime", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTime), arg0) 16662 } 16663 16664 // ModifyInstanceEventStartTimeWithContext mocks base method 16665 func (m *MockEC2API) ModifyInstanceEventStartTimeWithContext(arg0 aws.Context, arg1 *ec2.ModifyInstanceEventStartTimeInput, arg2 ...request.Option) (*ec2.ModifyInstanceEventStartTimeOutput, error) { 16666 m.ctrl.T.Helper() 16667 varargs := []interface{}{arg0, arg1} 16668 for _, a := range arg2 { 16669 varargs = append(varargs, a) 16670 } 16671 ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeWithContext", varargs...) 16672 ret0, _ := ret[0].(*ec2.ModifyInstanceEventStartTimeOutput) 16673 ret1, _ := ret[1].(error) 16674 return ret0, ret1 16675 } 16676 16677 // ModifyInstanceEventStartTimeWithContext indicates an expected call of ModifyInstanceEventStartTimeWithContext 16678 func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTimeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16679 mr.mock.ctrl.T.Helper() 16680 varargs := append([]interface{}{arg0, arg1}, arg2...) 16681 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTimeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTimeWithContext), varargs...) 16682 } 16683 16684 // ModifyInstanceEventStartTimeRequest mocks base method 16685 func (m *MockEC2API) ModifyInstanceEventStartTimeRequest(arg0 *ec2.ModifyInstanceEventStartTimeInput) (*request.Request, *ec2.ModifyInstanceEventStartTimeOutput) { 16686 m.ctrl.T.Helper() 16687 ret := m.ctrl.Call(m, "ModifyInstanceEventStartTimeRequest", arg0) 16688 ret0, _ := ret[0].(*request.Request) 16689 ret1, _ := ret[1].(*ec2.ModifyInstanceEventStartTimeOutput) 16690 return ret0, ret1 16691 } 16692 16693 // ModifyInstanceEventStartTimeRequest indicates an expected call of ModifyInstanceEventStartTimeRequest 16694 func (mr *MockEC2APIMockRecorder) ModifyInstanceEventStartTimeRequest(arg0 interface{}) *gomock.Call { 16695 mr.mock.ctrl.T.Helper() 16696 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstanceEventStartTimeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstanceEventStartTimeRequest), arg0) 16697 } 16698 16699 // ModifyInstancePlacement mocks base method 16700 func (m *MockEC2API) ModifyInstancePlacement(arg0 *ec2.ModifyInstancePlacementInput) (*ec2.ModifyInstancePlacementOutput, error) { 16701 m.ctrl.T.Helper() 16702 ret := m.ctrl.Call(m, "ModifyInstancePlacement", arg0) 16703 ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput) 16704 ret1, _ := ret[1].(error) 16705 return ret0, ret1 16706 } 16707 16708 // ModifyInstancePlacement indicates an expected call of ModifyInstancePlacement 16709 func (mr *MockEC2APIMockRecorder) ModifyInstancePlacement(arg0 interface{}) *gomock.Call { 16710 mr.mock.ctrl.T.Helper() 16711 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacement", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacement), arg0) 16712 } 16713 16714 // ModifyInstancePlacementWithContext mocks base method 16715 func (m *MockEC2API) ModifyInstancePlacementWithContext(arg0 aws.Context, arg1 *ec2.ModifyInstancePlacementInput, arg2 ...request.Option) (*ec2.ModifyInstancePlacementOutput, error) { 16716 m.ctrl.T.Helper() 16717 varargs := []interface{}{arg0, arg1} 16718 for _, a := range arg2 { 16719 varargs = append(varargs, a) 16720 } 16721 ret := m.ctrl.Call(m, "ModifyInstancePlacementWithContext", varargs...) 16722 ret0, _ := ret[0].(*ec2.ModifyInstancePlacementOutput) 16723 ret1, _ := ret[1].(error) 16724 return ret0, ret1 16725 } 16726 16727 // ModifyInstancePlacementWithContext indicates an expected call of ModifyInstancePlacementWithContext 16728 func (mr *MockEC2APIMockRecorder) ModifyInstancePlacementWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16729 mr.mock.ctrl.T.Helper() 16730 varargs := append([]interface{}{arg0, arg1}, arg2...) 16731 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacementWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacementWithContext), varargs...) 16732 } 16733 16734 // ModifyInstancePlacementRequest mocks base method 16735 func (m *MockEC2API) ModifyInstancePlacementRequest(arg0 *ec2.ModifyInstancePlacementInput) (*request.Request, *ec2.ModifyInstancePlacementOutput) { 16736 m.ctrl.T.Helper() 16737 ret := m.ctrl.Call(m, "ModifyInstancePlacementRequest", arg0) 16738 ret0, _ := ret[0].(*request.Request) 16739 ret1, _ := ret[1].(*ec2.ModifyInstancePlacementOutput) 16740 return ret0, ret1 16741 } 16742 16743 // ModifyInstancePlacementRequest indicates an expected call of ModifyInstancePlacementRequest 16744 func (mr *MockEC2APIMockRecorder) ModifyInstancePlacementRequest(arg0 interface{}) *gomock.Call { 16745 mr.mock.ctrl.T.Helper() 16746 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyInstancePlacementRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyInstancePlacementRequest), arg0) 16747 } 16748 16749 // ModifyLaunchTemplate mocks base method 16750 func (m *MockEC2API) ModifyLaunchTemplate(arg0 *ec2.ModifyLaunchTemplateInput) (*ec2.ModifyLaunchTemplateOutput, error) { 16751 m.ctrl.T.Helper() 16752 ret := m.ctrl.Call(m, "ModifyLaunchTemplate", arg0) 16753 ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput) 16754 ret1, _ := ret[1].(error) 16755 return ret0, ret1 16756 } 16757 16758 // ModifyLaunchTemplate indicates an expected call of ModifyLaunchTemplate 16759 func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplate(arg0 interface{}) *gomock.Call { 16760 mr.mock.ctrl.T.Helper() 16761 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplate", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplate), arg0) 16762 } 16763 16764 // ModifyLaunchTemplateWithContext mocks base method 16765 func (m *MockEC2API) ModifyLaunchTemplateWithContext(arg0 aws.Context, arg1 *ec2.ModifyLaunchTemplateInput, arg2 ...request.Option) (*ec2.ModifyLaunchTemplateOutput, error) { 16766 m.ctrl.T.Helper() 16767 varargs := []interface{}{arg0, arg1} 16768 for _, a := range arg2 { 16769 varargs = append(varargs, a) 16770 } 16771 ret := m.ctrl.Call(m, "ModifyLaunchTemplateWithContext", varargs...) 16772 ret0, _ := ret[0].(*ec2.ModifyLaunchTemplateOutput) 16773 ret1, _ := ret[1].(error) 16774 return ret0, ret1 16775 } 16776 16777 // ModifyLaunchTemplateWithContext indicates an expected call of ModifyLaunchTemplateWithContext 16778 func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16779 mr.mock.ctrl.T.Helper() 16780 varargs := append([]interface{}{arg0, arg1}, arg2...) 16781 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplateWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplateWithContext), varargs...) 16782 } 16783 16784 // ModifyLaunchTemplateRequest mocks base method 16785 func (m *MockEC2API) ModifyLaunchTemplateRequest(arg0 *ec2.ModifyLaunchTemplateInput) (*request.Request, *ec2.ModifyLaunchTemplateOutput) { 16786 m.ctrl.T.Helper() 16787 ret := m.ctrl.Call(m, "ModifyLaunchTemplateRequest", arg0) 16788 ret0, _ := ret[0].(*request.Request) 16789 ret1, _ := ret[1].(*ec2.ModifyLaunchTemplateOutput) 16790 return ret0, ret1 16791 } 16792 16793 // ModifyLaunchTemplateRequest indicates an expected call of ModifyLaunchTemplateRequest 16794 func (mr *MockEC2APIMockRecorder) ModifyLaunchTemplateRequest(arg0 interface{}) *gomock.Call { 16795 mr.mock.ctrl.T.Helper() 16796 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyLaunchTemplateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyLaunchTemplateRequest), arg0) 16797 } 16798 16799 // ModifyNetworkInterfaceAttribute mocks base method 16800 func (m *MockEC2API) ModifyNetworkInterfaceAttribute(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) { 16801 m.ctrl.T.Helper() 16802 ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttribute", arg0) 16803 ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput) 16804 ret1, _ := ret[1].(error) 16805 return ret0, ret1 16806 } 16807 16808 // ModifyNetworkInterfaceAttribute indicates an expected call of ModifyNetworkInterfaceAttribute 16809 func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { 16810 mr.mock.ctrl.T.Helper() 16811 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttribute), arg0) 16812 } 16813 16814 // ModifyNetworkInterfaceAttributeWithContext mocks base method 16815 func (m *MockEC2API) ModifyNetworkInterfaceAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifyNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ModifyNetworkInterfaceAttributeOutput, error) { 16816 m.ctrl.T.Helper() 16817 varargs := []interface{}{arg0, arg1} 16818 for _, a := range arg2 { 16819 varargs = append(varargs, a) 16820 } 16821 ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeWithContext", varargs...) 16822 ret0, _ := ret[0].(*ec2.ModifyNetworkInterfaceAttributeOutput) 16823 ret1, _ := ret[1].(error) 16824 return ret0, ret1 16825 } 16826 16827 // ModifyNetworkInterfaceAttributeWithContext indicates an expected call of ModifyNetworkInterfaceAttributeWithContext 16828 func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16829 mr.mock.ctrl.T.Helper() 16830 varargs := append([]interface{}{arg0, arg1}, arg2...) 16831 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeWithContext), varargs...) 16832 } 16833 16834 // ModifyNetworkInterfaceAttributeRequest mocks base method 16835 func (m *MockEC2API) ModifyNetworkInterfaceAttributeRequest(arg0 *ec2.ModifyNetworkInterfaceAttributeInput) (*request.Request, *ec2.ModifyNetworkInterfaceAttributeOutput) { 16836 m.ctrl.T.Helper() 16837 ret := m.ctrl.Call(m, "ModifyNetworkInterfaceAttributeRequest", arg0) 16838 ret0, _ := ret[0].(*request.Request) 16839 ret1, _ := ret[1].(*ec2.ModifyNetworkInterfaceAttributeOutput) 16840 return ret0, ret1 16841 } 16842 16843 // ModifyNetworkInterfaceAttributeRequest indicates an expected call of ModifyNetworkInterfaceAttributeRequest 16844 func (mr *MockEC2APIMockRecorder) ModifyNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { 16845 mr.mock.ctrl.T.Helper() 16846 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyNetworkInterfaceAttributeRequest), arg0) 16847 } 16848 16849 // ModifyReservedInstances mocks base method 16850 func (m *MockEC2API) ModifyReservedInstances(arg0 *ec2.ModifyReservedInstancesInput) (*ec2.ModifyReservedInstancesOutput, error) { 16851 m.ctrl.T.Helper() 16852 ret := m.ctrl.Call(m, "ModifyReservedInstances", arg0) 16853 ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput) 16854 ret1, _ := ret[1].(error) 16855 return ret0, ret1 16856 } 16857 16858 // ModifyReservedInstances indicates an expected call of ModifyReservedInstances 16859 func (mr *MockEC2APIMockRecorder) ModifyReservedInstances(arg0 interface{}) *gomock.Call { 16860 mr.mock.ctrl.T.Helper() 16861 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstances", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstances), arg0) 16862 } 16863 16864 // ModifyReservedInstancesWithContext mocks base method 16865 func (m *MockEC2API) ModifyReservedInstancesWithContext(arg0 aws.Context, arg1 *ec2.ModifyReservedInstancesInput, arg2 ...request.Option) (*ec2.ModifyReservedInstancesOutput, error) { 16866 m.ctrl.T.Helper() 16867 varargs := []interface{}{arg0, arg1} 16868 for _, a := range arg2 { 16869 varargs = append(varargs, a) 16870 } 16871 ret := m.ctrl.Call(m, "ModifyReservedInstancesWithContext", varargs...) 16872 ret0, _ := ret[0].(*ec2.ModifyReservedInstancesOutput) 16873 ret1, _ := ret[1].(error) 16874 return ret0, ret1 16875 } 16876 16877 // ModifyReservedInstancesWithContext indicates an expected call of ModifyReservedInstancesWithContext 16878 func (mr *MockEC2APIMockRecorder) ModifyReservedInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16879 mr.mock.ctrl.T.Helper() 16880 varargs := append([]interface{}{arg0, arg1}, arg2...) 16881 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstancesWithContext), varargs...) 16882 } 16883 16884 // ModifyReservedInstancesRequest mocks base method 16885 func (m *MockEC2API) ModifyReservedInstancesRequest(arg0 *ec2.ModifyReservedInstancesInput) (*request.Request, *ec2.ModifyReservedInstancesOutput) { 16886 m.ctrl.T.Helper() 16887 ret := m.ctrl.Call(m, "ModifyReservedInstancesRequest", arg0) 16888 ret0, _ := ret[0].(*request.Request) 16889 ret1, _ := ret[1].(*ec2.ModifyReservedInstancesOutput) 16890 return ret0, ret1 16891 } 16892 16893 // ModifyReservedInstancesRequest indicates an expected call of ModifyReservedInstancesRequest 16894 func (mr *MockEC2APIMockRecorder) ModifyReservedInstancesRequest(arg0 interface{}) *gomock.Call { 16895 mr.mock.ctrl.T.Helper() 16896 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyReservedInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyReservedInstancesRequest), arg0) 16897 } 16898 16899 // ModifySnapshotAttribute mocks base method 16900 func (m *MockEC2API) ModifySnapshotAttribute(arg0 *ec2.ModifySnapshotAttributeInput) (*ec2.ModifySnapshotAttributeOutput, error) { 16901 m.ctrl.T.Helper() 16902 ret := m.ctrl.Call(m, "ModifySnapshotAttribute", arg0) 16903 ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput) 16904 ret1, _ := ret[1].(error) 16905 return ret0, ret1 16906 } 16907 16908 // ModifySnapshotAttribute indicates an expected call of ModifySnapshotAttribute 16909 func (mr *MockEC2APIMockRecorder) ModifySnapshotAttribute(arg0 interface{}) *gomock.Call { 16910 mr.mock.ctrl.T.Helper() 16911 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttribute), arg0) 16912 } 16913 16914 // ModifySnapshotAttributeWithContext mocks base method 16915 func (m *MockEC2API) ModifySnapshotAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifySnapshotAttributeInput, arg2 ...request.Option) (*ec2.ModifySnapshotAttributeOutput, error) { 16916 m.ctrl.T.Helper() 16917 varargs := []interface{}{arg0, arg1} 16918 for _, a := range arg2 { 16919 varargs = append(varargs, a) 16920 } 16921 ret := m.ctrl.Call(m, "ModifySnapshotAttributeWithContext", varargs...) 16922 ret0, _ := ret[0].(*ec2.ModifySnapshotAttributeOutput) 16923 ret1, _ := ret[1].(error) 16924 return ret0, ret1 16925 } 16926 16927 // ModifySnapshotAttributeWithContext indicates an expected call of ModifySnapshotAttributeWithContext 16928 func (mr *MockEC2APIMockRecorder) ModifySnapshotAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16929 mr.mock.ctrl.T.Helper() 16930 varargs := append([]interface{}{arg0, arg1}, arg2...) 16931 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttributeWithContext), varargs...) 16932 } 16933 16934 // ModifySnapshotAttributeRequest mocks base method 16935 func (m *MockEC2API) ModifySnapshotAttributeRequest(arg0 *ec2.ModifySnapshotAttributeInput) (*request.Request, *ec2.ModifySnapshotAttributeOutput) { 16936 m.ctrl.T.Helper() 16937 ret := m.ctrl.Call(m, "ModifySnapshotAttributeRequest", arg0) 16938 ret0, _ := ret[0].(*request.Request) 16939 ret1, _ := ret[1].(*ec2.ModifySnapshotAttributeOutput) 16940 return ret0, ret1 16941 } 16942 16943 // ModifySnapshotAttributeRequest indicates an expected call of ModifySnapshotAttributeRequest 16944 func (mr *MockEC2APIMockRecorder) ModifySnapshotAttributeRequest(arg0 interface{}) *gomock.Call { 16945 mr.mock.ctrl.T.Helper() 16946 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySnapshotAttributeRequest), arg0) 16947 } 16948 16949 // ModifySpotFleetRequest mocks base method 16950 func (m *MockEC2API) ModifySpotFleetRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*ec2.ModifySpotFleetRequestOutput, error) { 16951 m.ctrl.T.Helper() 16952 ret := m.ctrl.Call(m, "ModifySpotFleetRequest", arg0) 16953 ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput) 16954 ret1, _ := ret[1].(error) 16955 return ret0, ret1 16956 } 16957 16958 // ModifySpotFleetRequest indicates an expected call of ModifySpotFleetRequest 16959 func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequest(arg0 interface{}) *gomock.Call { 16960 mr.mock.ctrl.T.Helper() 16961 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequest), arg0) 16962 } 16963 16964 // ModifySpotFleetRequestWithContext mocks base method 16965 func (m *MockEC2API) ModifySpotFleetRequestWithContext(arg0 aws.Context, arg1 *ec2.ModifySpotFleetRequestInput, arg2 ...request.Option) (*ec2.ModifySpotFleetRequestOutput, error) { 16966 m.ctrl.T.Helper() 16967 varargs := []interface{}{arg0, arg1} 16968 for _, a := range arg2 { 16969 varargs = append(varargs, a) 16970 } 16971 ret := m.ctrl.Call(m, "ModifySpotFleetRequestWithContext", varargs...) 16972 ret0, _ := ret[0].(*ec2.ModifySpotFleetRequestOutput) 16973 ret1, _ := ret[1].(error) 16974 return ret0, ret1 16975 } 16976 16977 // ModifySpotFleetRequestWithContext indicates an expected call of ModifySpotFleetRequestWithContext 16978 func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequestWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 16979 mr.mock.ctrl.T.Helper() 16980 varargs := append([]interface{}{arg0, arg1}, arg2...) 16981 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequestWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequestWithContext), varargs...) 16982 } 16983 16984 // ModifySpotFleetRequestRequest mocks base method 16985 func (m *MockEC2API) ModifySpotFleetRequestRequest(arg0 *ec2.ModifySpotFleetRequestInput) (*request.Request, *ec2.ModifySpotFleetRequestOutput) { 16986 m.ctrl.T.Helper() 16987 ret := m.ctrl.Call(m, "ModifySpotFleetRequestRequest", arg0) 16988 ret0, _ := ret[0].(*request.Request) 16989 ret1, _ := ret[1].(*ec2.ModifySpotFleetRequestOutput) 16990 return ret0, ret1 16991 } 16992 16993 // ModifySpotFleetRequestRequest indicates an expected call of ModifySpotFleetRequestRequest 16994 func (mr *MockEC2APIMockRecorder) ModifySpotFleetRequestRequest(arg0 interface{}) *gomock.Call { 16995 mr.mock.ctrl.T.Helper() 16996 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySpotFleetRequestRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySpotFleetRequestRequest), arg0) 16997 } 16998 16999 // ModifySubnetAttribute mocks base method 17000 func (m *MockEC2API) ModifySubnetAttribute(arg0 *ec2.ModifySubnetAttributeInput) (*ec2.ModifySubnetAttributeOutput, error) { 17001 m.ctrl.T.Helper() 17002 ret := m.ctrl.Call(m, "ModifySubnetAttribute", arg0) 17003 ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput) 17004 ret1, _ := ret[1].(error) 17005 return ret0, ret1 17006 } 17007 17008 // ModifySubnetAttribute indicates an expected call of ModifySubnetAttribute 17009 func (mr *MockEC2APIMockRecorder) ModifySubnetAttribute(arg0 interface{}) *gomock.Call { 17010 mr.mock.ctrl.T.Helper() 17011 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttribute), arg0) 17012 } 17013 17014 // ModifySubnetAttributeWithContext mocks base method 17015 func (m *MockEC2API) ModifySubnetAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifySubnetAttributeInput, arg2 ...request.Option) (*ec2.ModifySubnetAttributeOutput, error) { 17016 m.ctrl.T.Helper() 17017 varargs := []interface{}{arg0, arg1} 17018 for _, a := range arg2 { 17019 varargs = append(varargs, a) 17020 } 17021 ret := m.ctrl.Call(m, "ModifySubnetAttributeWithContext", varargs...) 17022 ret0, _ := ret[0].(*ec2.ModifySubnetAttributeOutput) 17023 ret1, _ := ret[1].(error) 17024 return ret0, ret1 17025 } 17026 17027 // ModifySubnetAttributeWithContext indicates an expected call of ModifySubnetAttributeWithContext 17028 func (mr *MockEC2APIMockRecorder) ModifySubnetAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17029 mr.mock.ctrl.T.Helper() 17030 varargs := append([]interface{}{arg0, arg1}, arg2...) 17031 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttributeWithContext), varargs...) 17032 } 17033 17034 // ModifySubnetAttributeRequest mocks base method 17035 func (m *MockEC2API) ModifySubnetAttributeRequest(arg0 *ec2.ModifySubnetAttributeInput) (*request.Request, *ec2.ModifySubnetAttributeOutput) { 17036 m.ctrl.T.Helper() 17037 ret := m.ctrl.Call(m, "ModifySubnetAttributeRequest", arg0) 17038 ret0, _ := ret[0].(*request.Request) 17039 ret1, _ := ret[1].(*ec2.ModifySubnetAttributeOutput) 17040 return ret0, ret1 17041 } 17042 17043 // ModifySubnetAttributeRequest indicates an expected call of ModifySubnetAttributeRequest 17044 func (mr *MockEC2APIMockRecorder) ModifySubnetAttributeRequest(arg0 interface{}) *gomock.Call { 17045 mr.mock.ctrl.T.Helper() 17046 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifySubnetAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifySubnetAttributeRequest), arg0) 17047 } 17048 17049 // ModifyTrafficMirrorFilterNetworkServices mocks base method 17050 func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServices(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) { 17051 m.ctrl.T.Helper() 17052 ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServices", arg0) 17053 ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) 17054 ret1, _ := ret[1].(error) 17055 return ret0, ret1 17056 } 17057 17058 // ModifyTrafficMirrorFilterNetworkServices indicates an expected call of ModifyTrafficMirrorFilterNetworkServices 17059 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServices(arg0 interface{}) *gomock.Call { 17060 mr.mock.ctrl.T.Helper() 17061 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServices", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServices), arg0) 17062 } 17063 17064 // ModifyTrafficMirrorFilterNetworkServicesWithContext mocks base method 17065 func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0 aws.Context, arg1 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput, error) { 17066 m.ctrl.T.Helper() 17067 varargs := []interface{}{arg0, arg1} 17068 for _, a := range arg2 { 17069 varargs = append(varargs, a) 17070 } 17071 ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesWithContext", varargs...) 17072 ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) 17073 ret1, _ := ret[1].(error) 17074 return ret0, ret1 17075 } 17076 17077 // ModifyTrafficMirrorFilterNetworkServicesWithContext indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesWithContext 17078 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServicesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17079 mr.mock.ctrl.T.Helper() 17080 varargs := append([]interface{}{arg0, arg1}, arg2...) 17081 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServicesWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesWithContext), varargs...) 17082 } 17083 17084 // ModifyTrafficMirrorFilterNetworkServicesRequest mocks base method 17085 func (m *MockEC2API) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 *ec2.ModifyTrafficMirrorFilterNetworkServicesInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) { 17086 m.ctrl.T.Helper() 17087 ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterNetworkServicesRequest", arg0) 17088 ret0, _ := ret[0].(*request.Request) 17089 ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterNetworkServicesOutput) 17090 return ret0, ret1 17091 } 17092 17093 // ModifyTrafficMirrorFilterNetworkServicesRequest indicates an expected call of ModifyTrafficMirrorFilterNetworkServicesRequest 17094 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterNetworkServicesRequest(arg0 interface{}) *gomock.Call { 17095 mr.mock.ctrl.T.Helper() 17096 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterNetworkServicesRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterNetworkServicesRequest), arg0) 17097 } 17098 17099 // ModifyTrafficMirrorFilterRule mocks base method 17100 func (m *MockEC2API) ModifyTrafficMirrorFilterRule(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) { 17101 m.ctrl.T.Helper() 17102 ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRule", arg0) 17103 ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput) 17104 ret1, _ := ret[1].(error) 17105 return ret0, ret1 17106 } 17107 17108 // ModifyTrafficMirrorFilterRule indicates an expected call of ModifyTrafficMirrorFilterRule 17109 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRule(arg0 interface{}) *gomock.Call { 17110 mr.mock.ctrl.T.Helper() 17111 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRule", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRule), arg0) 17112 } 17113 17114 // ModifyTrafficMirrorFilterRuleWithContext mocks base method 17115 func (m *MockEC2API) ModifyTrafficMirrorFilterRuleWithContext(arg0 aws.Context, arg1 *ec2.ModifyTrafficMirrorFilterRuleInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorFilterRuleOutput, error) { 17116 m.ctrl.T.Helper() 17117 varargs := []interface{}{arg0, arg1} 17118 for _, a := range arg2 { 17119 varargs = append(varargs, a) 17120 } 17121 ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleWithContext", varargs...) 17122 ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorFilterRuleOutput) 17123 ret1, _ := ret[1].(error) 17124 return ret0, ret1 17125 } 17126 17127 // ModifyTrafficMirrorFilterRuleWithContext indicates an expected call of ModifyTrafficMirrorFilterRuleWithContext 17128 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRuleWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17129 mr.mock.ctrl.T.Helper() 17130 varargs := append([]interface{}{arg0, arg1}, arg2...) 17131 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRuleWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleWithContext), varargs...) 17132 } 17133 17134 // ModifyTrafficMirrorFilterRuleRequest mocks base method 17135 func (m *MockEC2API) ModifyTrafficMirrorFilterRuleRequest(arg0 *ec2.ModifyTrafficMirrorFilterRuleInput) (*request.Request, *ec2.ModifyTrafficMirrorFilterRuleOutput) { 17136 m.ctrl.T.Helper() 17137 ret := m.ctrl.Call(m, "ModifyTrafficMirrorFilterRuleRequest", arg0) 17138 ret0, _ := ret[0].(*request.Request) 17139 ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorFilterRuleOutput) 17140 return ret0, ret1 17141 } 17142 17143 // ModifyTrafficMirrorFilterRuleRequest indicates an expected call of ModifyTrafficMirrorFilterRuleRequest 17144 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorFilterRuleRequest(arg0 interface{}) *gomock.Call { 17145 mr.mock.ctrl.T.Helper() 17146 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorFilterRuleRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorFilterRuleRequest), arg0) 17147 } 17148 17149 // ModifyTrafficMirrorSession mocks base method 17150 func (m *MockEC2API) ModifyTrafficMirrorSession(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*ec2.ModifyTrafficMirrorSessionOutput, error) { 17151 m.ctrl.T.Helper() 17152 ret := m.ctrl.Call(m, "ModifyTrafficMirrorSession", arg0) 17153 ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput) 17154 ret1, _ := ret[1].(error) 17155 return ret0, ret1 17156 } 17157 17158 // ModifyTrafficMirrorSession indicates an expected call of ModifyTrafficMirrorSession 17159 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSession(arg0 interface{}) *gomock.Call { 17160 mr.mock.ctrl.T.Helper() 17161 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSession", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSession), arg0) 17162 } 17163 17164 // ModifyTrafficMirrorSessionWithContext mocks base method 17165 func (m *MockEC2API) ModifyTrafficMirrorSessionWithContext(arg0 aws.Context, arg1 *ec2.ModifyTrafficMirrorSessionInput, arg2 ...request.Option) (*ec2.ModifyTrafficMirrorSessionOutput, error) { 17166 m.ctrl.T.Helper() 17167 varargs := []interface{}{arg0, arg1} 17168 for _, a := range arg2 { 17169 varargs = append(varargs, a) 17170 } 17171 ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionWithContext", varargs...) 17172 ret0, _ := ret[0].(*ec2.ModifyTrafficMirrorSessionOutput) 17173 ret1, _ := ret[1].(error) 17174 return ret0, ret1 17175 } 17176 17177 // ModifyTrafficMirrorSessionWithContext indicates an expected call of ModifyTrafficMirrorSessionWithContext 17178 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSessionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17179 mr.mock.ctrl.T.Helper() 17180 varargs := append([]interface{}{arg0, arg1}, arg2...) 17181 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSessionWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSessionWithContext), varargs...) 17182 } 17183 17184 // ModifyTrafficMirrorSessionRequest mocks base method 17185 func (m *MockEC2API) ModifyTrafficMirrorSessionRequest(arg0 *ec2.ModifyTrafficMirrorSessionInput) (*request.Request, *ec2.ModifyTrafficMirrorSessionOutput) { 17186 m.ctrl.T.Helper() 17187 ret := m.ctrl.Call(m, "ModifyTrafficMirrorSessionRequest", arg0) 17188 ret0, _ := ret[0].(*request.Request) 17189 ret1, _ := ret[1].(*ec2.ModifyTrafficMirrorSessionOutput) 17190 return ret0, ret1 17191 } 17192 17193 // ModifyTrafficMirrorSessionRequest indicates an expected call of ModifyTrafficMirrorSessionRequest 17194 func (mr *MockEC2APIMockRecorder) ModifyTrafficMirrorSessionRequest(arg0 interface{}) *gomock.Call { 17195 mr.mock.ctrl.T.Helper() 17196 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTrafficMirrorSessionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTrafficMirrorSessionRequest), arg0) 17197 } 17198 17199 // ModifyTransitGatewayVpcAttachment mocks base method 17200 func (m *MockEC2API) ModifyTransitGatewayVpcAttachment(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) { 17201 m.ctrl.T.Helper() 17202 ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachment", arg0) 17203 ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) 17204 ret1, _ := ret[1].(error) 17205 return ret0, ret1 17206 } 17207 17208 // ModifyTransitGatewayVpcAttachment indicates an expected call of ModifyTransitGatewayVpcAttachment 17209 func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { 17210 mr.mock.ctrl.T.Helper() 17211 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachment), arg0) 17212 } 17213 17214 // ModifyTransitGatewayVpcAttachmentWithContext mocks base method 17215 func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentWithContext(arg0 aws.Context, arg1 *ec2.ModifyTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.ModifyTransitGatewayVpcAttachmentOutput, error) { 17216 m.ctrl.T.Helper() 17217 varargs := []interface{}{arg0, arg1} 17218 for _, a := range arg2 { 17219 varargs = append(varargs, a) 17220 } 17221 ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentWithContext", varargs...) 17222 ret0, _ := ret[0].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) 17223 ret1, _ := ret[1].(error) 17224 return ret0, ret1 17225 } 17226 17227 // ModifyTransitGatewayVpcAttachmentWithContext indicates an expected call of ModifyTransitGatewayVpcAttachmentWithContext 17228 func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17229 mr.mock.ctrl.T.Helper() 17230 varargs := append([]interface{}{arg0, arg1}, arg2...) 17231 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentWithContext), varargs...) 17232 } 17233 17234 // ModifyTransitGatewayVpcAttachmentRequest mocks base method 17235 func (m *MockEC2API) ModifyTransitGatewayVpcAttachmentRequest(arg0 *ec2.ModifyTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.ModifyTransitGatewayVpcAttachmentOutput) { 17236 m.ctrl.T.Helper() 17237 ret := m.ctrl.Call(m, "ModifyTransitGatewayVpcAttachmentRequest", arg0) 17238 ret0, _ := ret[0].(*request.Request) 17239 ret1, _ := ret[1].(*ec2.ModifyTransitGatewayVpcAttachmentOutput) 17240 return ret0, ret1 17241 } 17242 17243 // ModifyTransitGatewayVpcAttachmentRequest indicates an expected call of ModifyTransitGatewayVpcAttachmentRequest 17244 func (mr *MockEC2APIMockRecorder) ModifyTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { 17245 mr.mock.ctrl.T.Helper() 17246 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyTransitGatewayVpcAttachmentRequest), arg0) 17247 } 17248 17249 // ModifyVolume mocks base method 17250 func (m *MockEC2API) ModifyVolume(arg0 *ec2.ModifyVolumeInput) (*ec2.ModifyVolumeOutput, error) { 17251 m.ctrl.T.Helper() 17252 ret := m.ctrl.Call(m, "ModifyVolume", arg0) 17253 ret0, _ := ret[0].(*ec2.ModifyVolumeOutput) 17254 ret1, _ := ret[1].(error) 17255 return ret0, ret1 17256 } 17257 17258 // ModifyVolume indicates an expected call of ModifyVolume 17259 func (mr *MockEC2APIMockRecorder) ModifyVolume(arg0 interface{}) *gomock.Call { 17260 mr.mock.ctrl.T.Helper() 17261 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolume", reflect.TypeOf((*MockEC2API)(nil).ModifyVolume), arg0) 17262 } 17263 17264 // ModifyVolumeWithContext mocks base method 17265 func (m *MockEC2API) ModifyVolumeWithContext(arg0 aws.Context, arg1 *ec2.ModifyVolumeInput, arg2 ...request.Option) (*ec2.ModifyVolumeOutput, error) { 17266 m.ctrl.T.Helper() 17267 varargs := []interface{}{arg0, arg1} 17268 for _, a := range arg2 { 17269 varargs = append(varargs, a) 17270 } 17271 ret := m.ctrl.Call(m, "ModifyVolumeWithContext", varargs...) 17272 ret0, _ := ret[0].(*ec2.ModifyVolumeOutput) 17273 ret1, _ := ret[1].(error) 17274 return ret0, ret1 17275 } 17276 17277 // ModifyVolumeWithContext indicates an expected call of ModifyVolumeWithContext 17278 func (mr *MockEC2APIMockRecorder) ModifyVolumeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17279 mr.mock.ctrl.T.Helper() 17280 varargs := append([]interface{}{arg0, arg1}, arg2...) 17281 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeWithContext), varargs...) 17282 } 17283 17284 // ModifyVolumeRequest mocks base method 17285 func (m *MockEC2API) ModifyVolumeRequest(arg0 *ec2.ModifyVolumeInput) (*request.Request, *ec2.ModifyVolumeOutput) { 17286 m.ctrl.T.Helper() 17287 ret := m.ctrl.Call(m, "ModifyVolumeRequest", arg0) 17288 ret0, _ := ret[0].(*request.Request) 17289 ret1, _ := ret[1].(*ec2.ModifyVolumeOutput) 17290 return ret0, ret1 17291 } 17292 17293 // ModifyVolumeRequest indicates an expected call of ModifyVolumeRequest 17294 func (mr *MockEC2APIMockRecorder) ModifyVolumeRequest(arg0 interface{}) *gomock.Call { 17295 mr.mock.ctrl.T.Helper() 17296 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeRequest), arg0) 17297 } 17298 17299 // ModifyVolumeAttribute mocks base method 17300 func (m *MockEC2API) ModifyVolumeAttribute(arg0 *ec2.ModifyVolumeAttributeInput) (*ec2.ModifyVolumeAttributeOutput, error) { 17301 m.ctrl.T.Helper() 17302 ret := m.ctrl.Call(m, "ModifyVolumeAttribute", arg0) 17303 ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput) 17304 ret1, _ := ret[1].(error) 17305 return ret0, ret1 17306 } 17307 17308 // ModifyVolumeAttribute indicates an expected call of ModifyVolumeAttribute 17309 func (mr *MockEC2APIMockRecorder) ModifyVolumeAttribute(arg0 interface{}) *gomock.Call { 17310 mr.mock.ctrl.T.Helper() 17311 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttribute), arg0) 17312 } 17313 17314 // ModifyVolumeAttributeWithContext mocks base method 17315 func (m *MockEC2API) ModifyVolumeAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifyVolumeAttributeInput, arg2 ...request.Option) (*ec2.ModifyVolumeAttributeOutput, error) { 17316 m.ctrl.T.Helper() 17317 varargs := []interface{}{arg0, arg1} 17318 for _, a := range arg2 { 17319 varargs = append(varargs, a) 17320 } 17321 ret := m.ctrl.Call(m, "ModifyVolumeAttributeWithContext", varargs...) 17322 ret0, _ := ret[0].(*ec2.ModifyVolumeAttributeOutput) 17323 ret1, _ := ret[1].(error) 17324 return ret0, ret1 17325 } 17326 17327 // ModifyVolumeAttributeWithContext indicates an expected call of ModifyVolumeAttributeWithContext 17328 func (mr *MockEC2APIMockRecorder) ModifyVolumeAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17329 mr.mock.ctrl.T.Helper() 17330 varargs := append([]interface{}{arg0, arg1}, arg2...) 17331 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttributeWithContext), varargs...) 17332 } 17333 17334 // ModifyVolumeAttributeRequest mocks base method 17335 func (m *MockEC2API) ModifyVolumeAttributeRequest(arg0 *ec2.ModifyVolumeAttributeInput) (*request.Request, *ec2.ModifyVolumeAttributeOutput) { 17336 m.ctrl.T.Helper() 17337 ret := m.ctrl.Call(m, "ModifyVolumeAttributeRequest", arg0) 17338 ret0, _ := ret[0].(*request.Request) 17339 ret1, _ := ret[1].(*ec2.ModifyVolumeAttributeOutput) 17340 return ret0, ret1 17341 } 17342 17343 // ModifyVolumeAttributeRequest indicates an expected call of ModifyVolumeAttributeRequest 17344 func (mr *MockEC2APIMockRecorder) ModifyVolumeAttributeRequest(arg0 interface{}) *gomock.Call { 17345 mr.mock.ctrl.T.Helper() 17346 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVolumeAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVolumeAttributeRequest), arg0) 17347 } 17348 17349 // ModifyVpcAttribute mocks base method 17350 func (m *MockEC2API) ModifyVpcAttribute(arg0 *ec2.ModifyVpcAttributeInput) (*ec2.ModifyVpcAttributeOutput, error) { 17351 m.ctrl.T.Helper() 17352 ret := m.ctrl.Call(m, "ModifyVpcAttribute", arg0) 17353 ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput) 17354 ret1, _ := ret[1].(error) 17355 return ret0, ret1 17356 } 17357 17358 // ModifyVpcAttribute indicates an expected call of ModifyVpcAttribute 17359 func (mr *MockEC2APIMockRecorder) ModifyVpcAttribute(arg0 interface{}) *gomock.Call { 17360 mr.mock.ctrl.T.Helper() 17361 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttribute", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttribute), arg0) 17362 } 17363 17364 // ModifyVpcAttributeWithContext mocks base method 17365 func (m *MockEC2API) ModifyVpcAttributeWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpcAttributeInput, arg2 ...request.Option) (*ec2.ModifyVpcAttributeOutput, error) { 17366 m.ctrl.T.Helper() 17367 varargs := []interface{}{arg0, arg1} 17368 for _, a := range arg2 { 17369 varargs = append(varargs, a) 17370 } 17371 ret := m.ctrl.Call(m, "ModifyVpcAttributeWithContext", varargs...) 17372 ret0, _ := ret[0].(*ec2.ModifyVpcAttributeOutput) 17373 ret1, _ := ret[1].(error) 17374 return ret0, ret1 17375 } 17376 17377 // ModifyVpcAttributeWithContext indicates an expected call of ModifyVpcAttributeWithContext 17378 func (mr *MockEC2APIMockRecorder) ModifyVpcAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17379 mr.mock.ctrl.T.Helper() 17380 varargs := append([]interface{}{arg0, arg1}, arg2...) 17381 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttributeWithContext), varargs...) 17382 } 17383 17384 // ModifyVpcAttributeRequest mocks base method 17385 func (m *MockEC2API) ModifyVpcAttributeRequest(arg0 *ec2.ModifyVpcAttributeInput) (*request.Request, *ec2.ModifyVpcAttributeOutput) { 17386 m.ctrl.T.Helper() 17387 ret := m.ctrl.Call(m, "ModifyVpcAttributeRequest", arg0) 17388 ret0, _ := ret[0].(*request.Request) 17389 ret1, _ := ret[1].(*ec2.ModifyVpcAttributeOutput) 17390 return ret0, ret1 17391 } 17392 17393 // ModifyVpcAttributeRequest indicates an expected call of ModifyVpcAttributeRequest 17394 func (mr *MockEC2APIMockRecorder) ModifyVpcAttributeRequest(arg0 interface{}) *gomock.Call { 17395 mr.mock.ctrl.T.Helper() 17396 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcAttributeRequest), arg0) 17397 } 17398 17399 // ModifyVpcEndpoint mocks base method 17400 func (m *MockEC2API) ModifyVpcEndpoint(arg0 *ec2.ModifyVpcEndpointInput) (*ec2.ModifyVpcEndpointOutput, error) { 17401 m.ctrl.T.Helper() 17402 ret := m.ctrl.Call(m, "ModifyVpcEndpoint", arg0) 17403 ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput) 17404 ret1, _ := ret[1].(error) 17405 return ret0, ret1 17406 } 17407 17408 // ModifyVpcEndpoint indicates an expected call of ModifyVpcEndpoint 17409 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpoint(arg0 interface{}) *gomock.Call { 17410 mr.mock.ctrl.T.Helper() 17411 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpoint", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpoint), arg0) 17412 } 17413 17414 // ModifyVpcEndpointWithContext mocks base method 17415 func (m *MockEC2API) ModifyVpcEndpointWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpcEndpointInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointOutput, error) { 17416 m.ctrl.T.Helper() 17417 varargs := []interface{}{arg0, arg1} 17418 for _, a := range arg2 { 17419 varargs = append(varargs, a) 17420 } 17421 ret := m.ctrl.Call(m, "ModifyVpcEndpointWithContext", varargs...) 17422 ret0, _ := ret[0].(*ec2.ModifyVpcEndpointOutput) 17423 ret1, _ := ret[1].(error) 17424 return ret0, ret1 17425 } 17426 17427 // ModifyVpcEndpointWithContext indicates an expected call of ModifyVpcEndpointWithContext 17428 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17429 mr.mock.ctrl.T.Helper() 17430 varargs := append([]interface{}{arg0, arg1}, arg2...) 17431 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointWithContext), varargs...) 17432 } 17433 17434 // ModifyVpcEndpointRequest mocks base method 17435 func (m *MockEC2API) ModifyVpcEndpointRequest(arg0 *ec2.ModifyVpcEndpointInput) (*request.Request, *ec2.ModifyVpcEndpointOutput) { 17436 m.ctrl.T.Helper() 17437 ret := m.ctrl.Call(m, "ModifyVpcEndpointRequest", arg0) 17438 ret0, _ := ret[0].(*request.Request) 17439 ret1, _ := ret[1].(*ec2.ModifyVpcEndpointOutput) 17440 return ret0, ret1 17441 } 17442 17443 // ModifyVpcEndpointRequest indicates an expected call of ModifyVpcEndpointRequest 17444 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointRequest(arg0 interface{}) *gomock.Call { 17445 mr.mock.ctrl.T.Helper() 17446 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointRequest), arg0) 17447 } 17448 17449 // ModifyVpcEndpointConnectionNotification mocks base method 17450 func (m *MockEC2API) ModifyVpcEndpointConnectionNotification(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) { 17451 m.ctrl.T.Helper() 17452 ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotification", arg0) 17453 ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) 17454 ret1, _ := ret[1].(error) 17455 return ret0, ret1 17456 } 17457 17458 // ModifyVpcEndpointConnectionNotification indicates an expected call of ModifyVpcEndpointConnectionNotification 17459 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotification(arg0 interface{}) *gomock.Call { 17460 mr.mock.ctrl.T.Helper() 17461 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotification", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotification), arg0) 17462 } 17463 17464 // ModifyVpcEndpointConnectionNotificationWithContext mocks base method 17465 func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpcEndpointConnectionNotificationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointConnectionNotificationOutput, error) { 17466 m.ctrl.T.Helper() 17467 varargs := []interface{}{arg0, arg1} 17468 for _, a := range arg2 { 17469 varargs = append(varargs, a) 17470 } 17471 ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationWithContext", varargs...) 17472 ret0, _ := ret[0].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) 17473 ret1, _ := ret[1].(error) 17474 return ret0, ret1 17475 } 17476 17477 // ModifyVpcEndpointConnectionNotificationWithContext indicates an expected call of ModifyVpcEndpointConnectionNotificationWithContext 17478 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotificationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17479 mr.mock.ctrl.T.Helper() 17480 varargs := append([]interface{}{arg0, arg1}, arg2...) 17481 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotificationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationWithContext), varargs...) 17482 } 17483 17484 // ModifyVpcEndpointConnectionNotificationRequest mocks base method 17485 func (m *MockEC2API) ModifyVpcEndpointConnectionNotificationRequest(arg0 *ec2.ModifyVpcEndpointConnectionNotificationInput) (*request.Request, *ec2.ModifyVpcEndpointConnectionNotificationOutput) { 17486 m.ctrl.T.Helper() 17487 ret := m.ctrl.Call(m, "ModifyVpcEndpointConnectionNotificationRequest", arg0) 17488 ret0, _ := ret[0].(*request.Request) 17489 ret1, _ := ret[1].(*ec2.ModifyVpcEndpointConnectionNotificationOutput) 17490 return ret0, ret1 17491 } 17492 17493 // ModifyVpcEndpointConnectionNotificationRequest indicates an expected call of ModifyVpcEndpointConnectionNotificationRequest 17494 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointConnectionNotificationRequest(arg0 interface{}) *gomock.Call { 17495 mr.mock.ctrl.T.Helper() 17496 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointConnectionNotificationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointConnectionNotificationRequest), arg0) 17497 } 17498 17499 // ModifyVpcEndpointServiceConfiguration mocks base method 17500 func (m *MockEC2API) ModifyVpcEndpointServiceConfiguration(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) { 17501 m.ctrl.T.Helper() 17502 ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfiguration", arg0) 17503 ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) 17504 ret1, _ := ret[1].(error) 17505 return ret0, ret1 17506 } 17507 17508 // ModifyVpcEndpointServiceConfiguration indicates an expected call of ModifyVpcEndpointServiceConfiguration 17509 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfiguration(arg0 interface{}) *gomock.Call { 17510 mr.mock.ctrl.T.Helper() 17511 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfiguration", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfiguration), arg0) 17512 } 17513 17514 // ModifyVpcEndpointServiceConfigurationWithContext mocks base method 17515 func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpcEndpointServiceConfigurationInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServiceConfigurationOutput, error) { 17516 m.ctrl.T.Helper() 17517 varargs := []interface{}{arg0, arg1} 17518 for _, a := range arg2 { 17519 varargs = append(varargs, a) 17520 } 17521 ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationWithContext", varargs...) 17522 ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) 17523 ret1, _ := ret[1].(error) 17524 return ret0, ret1 17525 } 17526 17527 // ModifyVpcEndpointServiceConfigurationWithContext indicates an expected call of ModifyVpcEndpointServiceConfigurationWithContext 17528 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfigurationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17529 mr.mock.ctrl.T.Helper() 17530 varargs := append([]interface{}{arg0, arg1}, arg2...) 17531 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfigurationWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationWithContext), varargs...) 17532 } 17533 17534 // ModifyVpcEndpointServiceConfigurationRequest mocks base method 17535 func (m *MockEC2API) ModifyVpcEndpointServiceConfigurationRequest(arg0 *ec2.ModifyVpcEndpointServiceConfigurationInput) (*request.Request, *ec2.ModifyVpcEndpointServiceConfigurationOutput) { 17536 m.ctrl.T.Helper() 17537 ret := m.ctrl.Call(m, "ModifyVpcEndpointServiceConfigurationRequest", arg0) 17538 ret0, _ := ret[0].(*request.Request) 17539 ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServiceConfigurationOutput) 17540 return ret0, ret1 17541 } 17542 17543 // ModifyVpcEndpointServiceConfigurationRequest indicates an expected call of ModifyVpcEndpointServiceConfigurationRequest 17544 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServiceConfigurationRequest(arg0 interface{}) *gomock.Call { 17545 mr.mock.ctrl.T.Helper() 17546 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServiceConfigurationRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServiceConfigurationRequest), arg0) 17547 } 17548 17549 // ModifyVpcEndpointServicePermissions mocks base method 17550 func (m *MockEC2API) ModifyVpcEndpointServicePermissions(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) { 17551 m.ctrl.T.Helper() 17552 ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissions", arg0) 17553 ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput) 17554 ret1, _ := ret[1].(error) 17555 return ret0, ret1 17556 } 17557 17558 // ModifyVpcEndpointServicePermissions indicates an expected call of ModifyVpcEndpointServicePermissions 17559 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissions(arg0 interface{}) *gomock.Call { 17560 mr.mock.ctrl.T.Helper() 17561 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissions), arg0) 17562 } 17563 17564 // ModifyVpcEndpointServicePermissionsWithContext mocks base method 17565 func (m *MockEC2API) ModifyVpcEndpointServicePermissionsWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpcEndpointServicePermissionsInput, arg2 ...request.Option) (*ec2.ModifyVpcEndpointServicePermissionsOutput, error) { 17566 m.ctrl.T.Helper() 17567 varargs := []interface{}{arg0, arg1} 17568 for _, a := range arg2 { 17569 varargs = append(varargs, a) 17570 } 17571 ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsWithContext", varargs...) 17572 ret0, _ := ret[0].(*ec2.ModifyVpcEndpointServicePermissionsOutput) 17573 ret1, _ := ret[1].(error) 17574 return ret0, ret1 17575 } 17576 17577 // ModifyVpcEndpointServicePermissionsWithContext indicates an expected call of ModifyVpcEndpointServicePermissionsWithContext 17578 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17579 mr.mock.ctrl.T.Helper() 17580 varargs := append([]interface{}{arg0, arg1}, arg2...) 17581 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsWithContext), varargs...) 17582 } 17583 17584 // ModifyVpcEndpointServicePermissionsRequest mocks base method 17585 func (m *MockEC2API) ModifyVpcEndpointServicePermissionsRequest(arg0 *ec2.ModifyVpcEndpointServicePermissionsInput) (*request.Request, *ec2.ModifyVpcEndpointServicePermissionsOutput) { 17586 m.ctrl.T.Helper() 17587 ret := m.ctrl.Call(m, "ModifyVpcEndpointServicePermissionsRequest", arg0) 17588 ret0, _ := ret[0].(*request.Request) 17589 ret1, _ := ret[1].(*ec2.ModifyVpcEndpointServicePermissionsOutput) 17590 return ret0, ret1 17591 } 17592 17593 // ModifyVpcEndpointServicePermissionsRequest indicates an expected call of ModifyVpcEndpointServicePermissionsRequest 17594 func (mr *MockEC2APIMockRecorder) ModifyVpcEndpointServicePermissionsRequest(arg0 interface{}) *gomock.Call { 17595 mr.mock.ctrl.T.Helper() 17596 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcEndpointServicePermissionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcEndpointServicePermissionsRequest), arg0) 17597 } 17598 17599 // ModifyVpcPeeringConnectionOptions mocks base method 17600 func (m *MockEC2API) ModifyVpcPeeringConnectionOptions(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) { 17601 m.ctrl.T.Helper() 17602 ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptions", arg0) 17603 ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) 17604 ret1, _ := ret[1].(error) 17605 return ret0, ret1 17606 } 17607 17608 // ModifyVpcPeeringConnectionOptions indicates an expected call of ModifyVpcPeeringConnectionOptions 17609 func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptions(arg0 interface{}) *gomock.Call { 17610 mr.mock.ctrl.T.Helper() 17611 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptions), arg0) 17612 } 17613 17614 // ModifyVpcPeeringConnectionOptionsWithContext mocks base method 17615 func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpcPeeringConnectionOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpcPeeringConnectionOptionsOutput, error) { 17616 m.ctrl.T.Helper() 17617 varargs := []interface{}{arg0, arg1} 17618 for _, a := range arg2 { 17619 varargs = append(varargs, a) 17620 } 17621 ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsWithContext", varargs...) 17622 ret0, _ := ret[0].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) 17623 ret1, _ := ret[1].(error) 17624 return ret0, ret1 17625 } 17626 17627 // ModifyVpcPeeringConnectionOptionsWithContext indicates an expected call of ModifyVpcPeeringConnectionOptionsWithContext 17628 func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17629 mr.mock.ctrl.T.Helper() 17630 varargs := append([]interface{}{arg0, arg1}, arg2...) 17631 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsWithContext), varargs...) 17632 } 17633 17634 // ModifyVpcPeeringConnectionOptionsRequest mocks base method 17635 func (m *MockEC2API) ModifyVpcPeeringConnectionOptionsRequest(arg0 *ec2.ModifyVpcPeeringConnectionOptionsInput) (*request.Request, *ec2.ModifyVpcPeeringConnectionOptionsOutput) { 17636 m.ctrl.T.Helper() 17637 ret := m.ctrl.Call(m, "ModifyVpcPeeringConnectionOptionsRequest", arg0) 17638 ret0, _ := ret[0].(*request.Request) 17639 ret1, _ := ret[1].(*ec2.ModifyVpcPeeringConnectionOptionsOutput) 17640 return ret0, ret1 17641 } 17642 17643 // ModifyVpcPeeringConnectionOptionsRequest indicates an expected call of ModifyVpcPeeringConnectionOptionsRequest 17644 func (mr *MockEC2APIMockRecorder) ModifyVpcPeeringConnectionOptionsRequest(arg0 interface{}) *gomock.Call { 17645 mr.mock.ctrl.T.Helper() 17646 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcPeeringConnectionOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcPeeringConnectionOptionsRequest), arg0) 17647 } 17648 17649 // ModifyVpcTenancy mocks base method 17650 func (m *MockEC2API) ModifyVpcTenancy(arg0 *ec2.ModifyVpcTenancyInput) (*ec2.ModifyVpcTenancyOutput, error) { 17651 m.ctrl.T.Helper() 17652 ret := m.ctrl.Call(m, "ModifyVpcTenancy", arg0) 17653 ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput) 17654 ret1, _ := ret[1].(error) 17655 return ret0, ret1 17656 } 17657 17658 // ModifyVpcTenancy indicates an expected call of ModifyVpcTenancy 17659 func (mr *MockEC2APIMockRecorder) ModifyVpcTenancy(arg0 interface{}) *gomock.Call { 17660 mr.mock.ctrl.T.Helper() 17661 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancy", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancy), arg0) 17662 } 17663 17664 // ModifyVpcTenancyWithContext mocks base method 17665 func (m *MockEC2API) ModifyVpcTenancyWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpcTenancyInput, arg2 ...request.Option) (*ec2.ModifyVpcTenancyOutput, error) { 17666 m.ctrl.T.Helper() 17667 varargs := []interface{}{arg0, arg1} 17668 for _, a := range arg2 { 17669 varargs = append(varargs, a) 17670 } 17671 ret := m.ctrl.Call(m, "ModifyVpcTenancyWithContext", varargs...) 17672 ret0, _ := ret[0].(*ec2.ModifyVpcTenancyOutput) 17673 ret1, _ := ret[1].(error) 17674 return ret0, ret1 17675 } 17676 17677 // ModifyVpcTenancyWithContext indicates an expected call of ModifyVpcTenancyWithContext 17678 func (mr *MockEC2APIMockRecorder) ModifyVpcTenancyWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17679 mr.mock.ctrl.T.Helper() 17680 varargs := append([]interface{}{arg0, arg1}, arg2...) 17681 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancyWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancyWithContext), varargs...) 17682 } 17683 17684 // ModifyVpcTenancyRequest mocks base method 17685 func (m *MockEC2API) ModifyVpcTenancyRequest(arg0 *ec2.ModifyVpcTenancyInput) (*request.Request, *ec2.ModifyVpcTenancyOutput) { 17686 m.ctrl.T.Helper() 17687 ret := m.ctrl.Call(m, "ModifyVpcTenancyRequest", arg0) 17688 ret0, _ := ret[0].(*request.Request) 17689 ret1, _ := ret[1].(*ec2.ModifyVpcTenancyOutput) 17690 return ret0, ret1 17691 } 17692 17693 // ModifyVpcTenancyRequest indicates an expected call of ModifyVpcTenancyRequest 17694 func (mr *MockEC2APIMockRecorder) ModifyVpcTenancyRequest(arg0 interface{}) *gomock.Call { 17695 mr.mock.ctrl.T.Helper() 17696 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpcTenancyRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpcTenancyRequest), arg0) 17697 } 17698 17699 // ModifyVpnConnection mocks base method 17700 func (m *MockEC2API) ModifyVpnConnection(arg0 *ec2.ModifyVpnConnectionInput) (*ec2.ModifyVpnConnectionOutput, error) { 17701 m.ctrl.T.Helper() 17702 ret := m.ctrl.Call(m, "ModifyVpnConnection", arg0) 17703 ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput) 17704 ret1, _ := ret[1].(error) 17705 return ret0, ret1 17706 } 17707 17708 // ModifyVpnConnection indicates an expected call of ModifyVpnConnection 17709 func (mr *MockEC2APIMockRecorder) ModifyVpnConnection(arg0 interface{}) *gomock.Call { 17710 mr.mock.ctrl.T.Helper() 17711 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnection", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnection), arg0) 17712 } 17713 17714 // ModifyVpnConnectionWithContext mocks base method 17715 func (m *MockEC2API) ModifyVpnConnectionWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpnConnectionInput, arg2 ...request.Option) (*ec2.ModifyVpnConnectionOutput, error) { 17716 m.ctrl.T.Helper() 17717 varargs := []interface{}{arg0, arg1} 17718 for _, a := range arg2 { 17719 varargs = append(varargs, a) 17720 } 17721 ret := m.ctrl.Call(m, "ModifyVpnConnectionWithContext", varargs...) 17722 ret0, _ := ret[0].(*ec2.ModifyVpnConnectionOutput) 17723 ret1, _ := ret[1].(error) 17724 return ret0, ret1 17725 } 17726 17727 // ModifyVpnConnectionWithContext indicates an expected call of ModifyVpnConnectionWithContext 17728 func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17729 mr.mock.ctrl.T.Helper() 17730 varargs := append([]interface{}{arg0, arg1}, arg2...) 17731 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionWithContext), varargs...) 17732 } 17733 17734 // ModifyVpnConnectionRequest mocks base method 17735 func (m *MockEC2API) ModifyVpnConnectionRequest(arg0 *ec2.ModifyVpnConnectionInput) (*request.Request, *ec2.ModifyVpnConnectionOutput) { 17736 m.ctrl.T.Helper() 17737 ret := m.ctrl.Call(m, "ModifyVpnConnectionRequest", arg0) 17738 ret0, _ := ret[0].(*request.Request) 17739 ret1, _ := ret[1].(*ec2.ModifyVpnConnectionOutput) 17740 return ret0, ret1 17741 } 17742 17743 // ModifyVpnConnectionRequest indicates an expected call of ModifyVpnConnectionRequest 17744 func (mr *MockEC2APIMockRecorder) ModifyVpnConnectionRequest(arg0 interface{}) *gomock.Call { 17745 mr.mock.ctrl.T.Helper() 17746 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnConnectionRequest), arg0) 17747 } 17748 17749 // ModifyVpnTunnelCertificate mocks base method 17750 func (m *MockEC2API) ModifyVpnTunnelCertificate(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*ec2.ModifyVpnTunnelCertificateOutput, error) { 17751 m.ctrl.T.Helper() 17752 ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificate", arg0) 17753 ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput) 17754 ret1, _ := ret[1].(error) 17755 return ret0, ret1 17756 } 17757 17758 // ModifyVpnTunnelCertificate indicates an expected call of ModifyVpnTunnelCertificate 17759 func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificate(arg0 interface{}) *gomock.Call { 17760 mr.mock.ctrl.T.Helper() 17761 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificate", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificate), arg0) 17762 } 17763 17764 // ModifyVpnTunnelCertificateWithContext mocks base method 17765 func (m *MockEC2API) ModifyVpnTunnelCertificateWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpnTunnelCertificateInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelCertificateOutput, error) { 17766 m.ctrl.T.Helper() 17767 varargs := []interface{}{arg0, arg1} 17768 for _, a := range arg2 { 17769 varargs = append(varargs, a) 17770 } 17771 ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateWithContext", varargs...) 17772 ret0, _ := ret[0].(*ec2.ModifyVpnTunnelCertificateOutput) 17773 ret1, _ := ret[1].(error) 17774 return ret0, ret1 17775 } 17776 17777 // ModifyVpnTunnelCertificateWithContext indicates an expected call of ModifyVpnTunnelCertificateWithContext 17778 func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificateWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17779 mr.mock.ctrl.T.Helper() 17780 varargs := append([]interface{}{arg0, arg1}, arg2...) 17781 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificateWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificateWithContext), varargs...) 17782 } 17783 17784 // ModifyVpnTunnelCertificateRequest mocks base method 17785 func (m *MockEC2API) ModifyVpnTunnelCertificateRequest(arg0 *ec2.ModifyVpnTunnelCertificateInput) (*request.Request, *ec2.ModifyVpnTunnelCertificateOutput) { 17786 m.ctrl.T.Helper() 17787 ret := m.ctrl.Call(m, "ModifyVpnTunnelCertificateRequest", arg0) 17788 ret0, _ := ret[0].(*request.Request) 17789 ret1, _ := ret[1].(*ec2.ModifyVpnTunnelCertificateOutput) 17790 return ret0, ret1 17791 } 17792 17793 // ModifyVpnTunnelCertificateRequest indicates an expected call of ModifyVpnTunnelCertificateRequest 17794 func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelCertificateRequest(arg0 interface{}) *gomock.Call { 17795 mr.mock.ctrl.T.Helper() 17796 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelCertificateRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelCertificateRequest), arg0) 17797 } 17798 17799 // ModifyVpnTunnelOptions mocks base method 17800 func (m *MockEC2API) ModifyVpnTunnelOptions(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*ec2.ModifyVpnTunnelOptionsOutput, error) { 17801 m.ctrl.T.Helper() 17802 ret := m.ctrl.Call(m, "ModifyVpnTunnelOptions", arg0) 17803 ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput) 17804 ret1, _ := ret[1].(error) 17805 return ret0, ret1 17806 } 17807 17808 // ModifyVpnTunnelOptions indicates an expected call of ModifyVpnTunnelOptions 17809 func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptions(arg0 interface{}) *gomock.Call { 17810 mr.mock.ctrl.T.Helper() 17811 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptions", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptions), arg0) 17812 } 17813 17814 // ModifyVpnTunnelOptionsWithContext mocks base method 17815 func (m *MockEC2API) ModifyVpnTunnelOptionsWithContext(arg0 aws.Context, arg1 *ec2.ModifyVpnTunnelOptionsInput, arg2 ...request.Option) (*ec2.ModifyVpnTunnelOptionsOutput, error) { 17816 m.ctrl.T.Helper() 17817 varargs := []interface{}{arg0, arg1} 17818 for _, a := range arg2 { 17819 varargs = append(varargs, a) 17820 } 17821 ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsWithContext", varargs...) 17822 ret0, _ := ret[0].(*ec2.ModifyVpnTunnelOptionsOutput) 17823 ret1, _ := ret[1].(error) 17824 return ret0, ret1 17825 } 17826 17827 // ModifyVpnTunnelOptionsWithContext indicates an expected call of ModifyVpnTunnelOptionsWithContext 17828 func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17829 mr.mock.ctrl.T.Helper() 17830 varargs := append([]interface{}{arg0, arg1}, arg2...) 17831 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptionsWithContext", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptionsWithContext), varargs...) 17832 } 17833 17834 // ModifyVpnTunnelOptionsRequest mocks base method 17835 func (m *MockEC2API) ModifyVpnTunnelOptionsRequest(arg0 *ec2.ModifyVpnTunnelOptionsInput) (*request.Request, *ec2.ModifyVpnTunnelOptionsOutput) { 17836 m.ctrl.T.Helper() 17837 ret := m.ctrl.Call(m, "ModifyVpnTunnelOptionsRequest", arg0) 17838 ret0, _ := ret[0].(*request.Request) 17839 ret1, _ := ret[1].(*ec2.ModifyVpnTunnelOptionsOutput) 17840 return ret0, ret1 17841 } 17842 17843 // ModifyVpnTunnelOptionsRequest indicates an expected call of ModifyVpnTunnelOptionsRequest 17844 func (mr *MockEC2APIMockRecorder) ModifyVpnTunnelOptionsRequest(arg0 interface{}) *gomock.Call { 17845 mr.mock.ctrl.T.Helper() 17846 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ModifyVpnTunnelOptionsRequest", reflect.TypeOf((*MockEC2API)(nil).ModifyVpnTunnelOptionsRequest), arg0) 17847 } 17848 17849 // MonitorInstances mocks base method 17850 func (m *MockEC2API) MonitorInstances(arg0 *ec2.MonitorInstancesInput) (*ec2.MonitorInstancesOutput, error) { 17851 m.ctrl.T.Helper() 17852 ret := m.ctrl.Call(m, "MonitorInstances", arg0) 17853 ret0, _ := ret[0].(*ec2.MonitorInstancesOutput) 17854 ret1, _ := ret[1].(error) 17855 return ret0, ret1 17856 } 17857 17858 // MonitorInstances indicates an expected call of MonitorInstances 17859 func (mr *MockEC2APIMockRecorder) MonitorInstances(arg0 interface{}) *gomock.Call { 17860 mr.mock.ctrl.T.Helper() 17861 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstances", reflect.TypeOf((*MockEC2API)(nil).MonitorInstances), arg0) 17862 } 17863 17864 // MonitorInstancesWithContext mocks base method 17865 func (m *MockEC2API) MonitorInstancesWithContext(arg0 aws.Context, arg1 *ec2.MonitorInstancesInput, arg2 ...request.Option) (*ec2.MonitorInstancesOutput, error) { 17866 m.ctrl.T.Helper() 17867 varargs := []interface{}{arg0, arg1} 17868 for _, a := range arg2 { 17869 varargs = append(varargs, a) 17870 } 17871 ret := m.ctrl.Call(m, "MonitorInstancesWithContext", varargs...) 17872 ret0, _ := ret[0].(*ec2.MonitorInstancesOutput) 17873 ret1, _ := ret[1].(error) 17874 return ret0, ret1 17875 } 17876 17877 // MonitorInstancesWithContext indicates an expected call of MonitorInstancesWithContext 17878 func (mr *MockEC2APIMockRecorder) MonitorInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17879 mr.mock.ctrl.T.Helper() 17880 varargs := append([]interface{}{arg0, arg1}, arg2...) 17881 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).MonitorInstancesWithContext), varargs...) 17882 } 17883 17884 // MonitorInstancesRequest mocks base method 17885 func (m *MockEC2API) MonitorInstancesRequest(arg0 *ec2.MonitorInstancesInput) (*request.Request, *ec2.MonitorInstancesOutput) { 17886 m.ctrl.T.Helper() 17887 ret := m.ctrl.Call(m, "MonitorInstancesRequest", arg0) 17888 ret0, _ := ret[0].(*request.Request) 17889 ret1, _ := ret[1].(*ec2.MonitorInstancesOutput) 17890 return ret0, ret1 17891 } 17892 17893 // MonitorInstancesRequest indicates an expected call of MonitorInstancesRequest 17894 func (mr *MockEC2APIMockRecorder) MonitorInstancesRequest(arg0 interface{}) *gomock.Call { 17895 mr.mock.ctrl.T.Helper() 17896 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).MonitorInstancesRequest), arg0) 17897 } 17898 17899 // MoveAddressToVpc mocks base method 17900 func (m *MockEC2API) MoveAddressToVpc(arg0 *ec2.MoveAddressToVpcInput) (*ec2.MoveAddressToVpcOutput, error) { 17901 m.ctrl.T.Helper() 17902 ret := m.ctrl.Call(m, "MoveAddressToVpc", arg0) 17903 ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput) 17904 ret1, _ := ret[1].(error) 17905 return ret0, ret1 17906 } 17907 17908 // MoveAddressToVpc indicates an expected call of MoveAddressToVpc 17909 func (mr *MockEC2APIMockRecorder) MoveAddressToVpc(arg0 interface{}) *gomock.Call { 17910 mr.mock.ctrl.T.Helper() 17911 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpc", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpc), arg0) 17912 } 17913 17914 // MoveAddressToVpcWithContext mocks base method 17915 func (m *MockEC2API) MoveAddressToVpcWithContext(arg0 aws.Context, arg1 *ec2.MoveAddressToVpcInput, arg2 ...request.Option) (*ec2.MoveAddressToVpcOutput, error) { 17916 m.ctrl.T.Helper() 17917 varargs := []interface{}{arg0, arg1} 17918 for _, a := range arg2 { 17919 varargs = append(varargs, a) 17920 } 17921 ret := m.ctrl.Call(m, "MoveAddressToVpcWithContext", varargs...) 17922 ret0, _ := ret[0].(*ec2.MoveAddressToVpcOutput) 17923 ret1, _ := ret[1].(error) 17924 return ret0, ret1 17925 } 17926 17927 // MoveAddressToVpcWithContext indicates an expected call of MoveAddressToVpcWithContext 17928 func (mr *MockEC2APIMockRecorder) MoveAddressToVpcWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17929 mr.mock.ctrl.T.Helper() 17930 varargs := append([]interface{}{arg0, arg1}, arg2...) 17931 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpcWithContext", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpcWithContext), varargs...) 17932 } 17933 17934 // MoveAddressToVpcRequest mocks base method 17935 func (m *MockEC2API) MoveAddressToVpcRequest(arg0 *ec2.MoveAddressToVpcInput) (*request.Request, *ec2.MoveAddressToVpcOutput) { 17936 m.ctrl.T.Helper() 17937 ret := m.ctrl.Call(m, "MoveAddressToVpcRequest", arg0) 17938 ret0, _ := ret[0].(*request.Request) 17939 ret1, _ := ret[1].(*ec2.MoveAddressToVpcOutput) 17940 return ret0, ret1 17941 } 17942 17943 // MoveAddressToVpcRequest indicates an expected call of MoveAddressToVpcRequest 17944 func (mr *MockEC2APIMockRecorder) MoveAddressToVpcRequest(arg0 interface{}) *gomock.Call { 17945 mr.mock.ctrl.T.Helper() 17946 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAddressToVpcRequest", reflect.TypeOf((*MockEC2API)(nil).MoveAddressToVpcRequest), arg0) 17947 } 17948 17949 // ProvisionByoipCidr mocks base method 17950 func (m *MockEC2API) ProvisionByoipCidr(arg0 *ec2.ProvisionByoipCidrInput) (*ec2.ProvisionByoipCidrOutput, error) { 17951 m.ctrl.T.Helper() 17952 ret := m.ctrl.Call(m, "ProvisionByoipCidr", arg0) 17953 ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput) 17954 ret1, _ := ret[1].(error) 17955 return ret0, ret1 17956 } 17957 17958 // ProvisionByoipCidr indicates an expected call of ProvisionByoipCidr 17959 func (mr *MockEC2APIMockRecorder) ProvisionByoipCidr(arg0 interface{}) *gomock.Call { 17960 mr.mock.ctrl.T.Helper() 17961 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidr", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidr), arg0) 17962 } 17963 17964 // ProvisionByoipCidrWithContext mocks base method 17965 func (m *MockEC2API) ProvisionByoipCidrWithContext(arg0 aws.Context, arg1 *ec2.ProvisionByoipCidrInput, arg2 ...request.Option) (*ec2.ProvisionByoipCidrOutput, error) { 17966 m.ctrl.T.Helper() 17967 varargs := []interface{}{arg0, arg1} 17968 for _, a := range arg2 { 17969 varargs = append(varargs, a) 17970 } 17971 ret := m.ctrl.Call(m, "ProvisionByoipCidrWithContext", varargs...) 17972 ret0, _ := ret[0].(*ec2.ProvisionByoipCidrOutput) 17973 ret1, _ := ret[1].(error) 17974 return ret0, ret1 17975 } 17976 17977 // ProvisionByoipCidrWithContext indicates an expected call of ProvisionByoipCidrWithContext 17978 func (mr *MockEC2APIMockRecorder) ProvisionByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 17979 mr.mock.ctrl.T.Helper() 17980 varargs := append([]interface{}{arg0, arg1}, arg2...) 17981 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidrWithContext), varargs...) 17982 } 17983 17984 // ProvisionByoipCidrRequest mocks base method 17985 func (m *MockEC2API) ProvisionByoipCidrRequest(arg0 *ec2.ProvisionByoipCidrInput) (*request.Request, *ec2.ProvisionByoipCidrOutput) { 17986 m.ctrl.T.Helper() 17987 ret := m.ctrl.Call(m, "ProvisionByoipCidrRequest", arg0) 17988 ret0, _ := ret[0].(*request.Request) 17989 ret1, _ := ret[1].(*ec2.ProvisionByoipCidrOutput) 17990 return ret0, ret1 17991 } 17992 17993 // ProvisionByoipCidrRequest indicates an expected call of ProvisionByoipCidrRequest 17994 func (mr *MockEC2APIMockRecorder) ProvisionByoipCidrRequest(arg0 interface{}) *gomock.Call { 17995 mr.mock.ctrl.T.Helper() 17996 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisionByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).ProvisionByoipCidrRequest), arg0) 17997 } 17998 17999 // PurchaseHostReservation mocks base method 18000 func (m *MockEC2API) PurchaseHostReservation(arg0 *ec2.PurchaseHostReservationInput) (*ec2.PurchaseHostReservationOutput, error) { 18001 m.ctrl.T.Helper() 18002 ret := m.ctrl.Call(m, "PurchaseHostReservation", arg0) 18003 ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput) 18004 ret1, _ := ret[1].(error) 18005 return ret0, ret1 18006 } 18007 18008 // PurchaseHostReservation indicates an expected call of PurchaseHostReservation 18009 func (mr *MockEC2APIMockRecorder) PurchaseHostReservation(arg0 interface{}) *gomock.Call { 18010 mr.mock.ctrl.T.Helper() 18011 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservation", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservation), arg0) 18012 } 18013 18014 // PurchaseHostReservationWithContext mocks base method 18015 func (m *MockEC2API) PurchaseHostReservationWithContext(arg0 aws.Context, arg1 *ec2.PurchaseHostReservationInput, arg2 ...request.Option) (*ec2.PurchaseHostReservationOutput, error) { 18016 m.ctrl.T.Helper() 18017 varargs := []interface{}{arg0, arg1} 18018 for _, a := range arg2 { 18019 varargs = append(varargs, a) 18020 } 18021 ret := m.ctrl.Call(m, "PurchaseHostReservationWithContext", varargs...) 18022 ret0, _ := ret[0].(*ec2.PurchaseHostReservationOutput) 18023 ret1, _ := ret[1].(error) 18024 return ret0, ret1 18025 } 18026 18027 // PurchaseHostReservationWithContext indicates an expected call of PurchaseHostReservationWithContext 18028 func (mr *MockEC2APIMockRecorder) PurchaseHostReservationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18029 mr.mock.ctrl.T.Helper() 18030 varargs := append([]interface{}{arg0, arg1}, arg2...) 18031 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservationWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservationWithContext), varargs...) 18032 } 18033 18034 // PurchaseHostReservationRequest mocks base method 18035 func (m *MockEC2API) PurchaseHostReservationRequest(arg0 *ec2.PurchaseHostReservationInput) (*request.Request, *ec2.PurchaseHostReservationOutput) { 18036 m.ctrl.T.Helper() 18037 ret := m.ctrl.Call(m, "PurchaseHostReservationRequest", arg0) 18038 ret0, _ := ret[0].(*request.Request) 18039 ret1, _ := ret[1].(*ec2.PurchaseHostReservationOutput) 18040 return ret0, ret1 18041 } 18042 18043 // PurchaseHostReservationRequest indicates an expected call of PurchaseHostReservationRequest 18044 func (mr *MockEC2APIMockRecorder) PurchaseHostReservationRequest(arg0 interface{}) *gomock.Call { 18045 mr.mock.ctrl.T.Helper() 18046 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseHostReservationRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseHostReservationRequest), arg0) 18047 } 18048 18049 // PurchaseReservedInstancesOffering mocks base method 18050 func (m *MockEC2API) PurchaseReservedInstancesOffering(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*ec2.PurchaseReservedInstancesOfferingOutput, error) { 18051 m.ctrl.T.Helper() 18052 ret := m.ctrl.Call(m, "PurchaseReservedInstancesOffering", arg0) 18053 ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput) 18054 ret1, _ := ret[1].(error) 18055 return ret0, ret1 18056 } 18057 18058 // PurchaseReservedInstancesOffering indicates an expected call of PurchaseReservedInstancesOffering 18059 func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOffering(arg0 interface{}) *gomock.Call { 18060 mr.mock.ctrl.T.Helper() 18061 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOffering", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOffering), arg0) 18062 } 18063 18064 // PurchaseReservedInstancesOfferingWithContext mocks base method 18065 func (m *MockEC2API) PurchaseReservedInstancesOfferingWithContext(arg0 aws.Context, arg1 *ec2.PurchaseReservedInstancesOfferingInput, arg2 ...request.Option) (*ec2.PurchaseReservedInstancesOfferingOutput, error) { 18066 m.ctrl.T.Helper() 18067 varargs := []interface{}{arg0, arg1} 18068 for _, a := range arg2 { 18069 varargs = append(varargs, a) 18070 } 18071 ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingWithContext", varargs...) 18072 ret0, _ := ret[0].(*ec2.PurchaseReservedInstancesOfferingOutput) 18073 ret1, _ := ret[1].(error) 18074 return ret0, ret1 18075 } 18076 18077 // PurchaseReservedInstancesOfferingWithContext indicates an expected call of PurchaseReservedInstancesOfferingWithContext 18078 func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOfferingWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18079 mr.mock.ctrl.T.Helper() 18080 varargs := append([]interface{}{arg0, arg1}, arg2...) 18081 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOfferingWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOfferingWithContext), varargs...) 18082 } 18083 18084 // PurchaseReservedInstancesOfferingRequest mocks base method 18085 func (m *MockEC2API) PurchaseReservedInstancesOfferingRequest(arg0 *ec2.PurchaseReservedInstancesOfferingInput) (*request.Request, *ec2.PurchaseReservedInstancesOfferingOutput) { 18086 m.ctrl.T.Helper() 18087 ret := m.ctrl.Call(m, "PurchaseReservedInstancesOfferingRequest", arg0) 18088 ret0, _ := ret[0].(*request.Request) 18089 ret1, _ := ret[1].(*ec2.PurchaseReservedInstancesOfferingOutput) 18090 return ret0, ret1 18091 } 18092 18093 // PurchaseReservedInstancesOfferingRequest indicates an expected call of PurchaseReservedInstancesOfferingRequest 18094 func (mr *MockEC2APIMockRecorder) PurchaseReservedInstancesOfferingRequest(arg0 interface{}) *gomock.Call { 18095 mr.mock.ctrl.T.Helper() 18096 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseReservedInstancesOfferingRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseReservedInstancesOfferingRequest), arg0) 18097 } 18098 18099 // PurchaseScheduledInstances mocks base method 18100 func (m *MockEC2API) PurchaseScheduledInstances(arg0 *ec2.PurchaseScheduledInstancesInput) (*ec2.PurchaseScheduledInstancesOutput, error) { 18101 m.ctrl.T.Helper() 18102 ret := m.ctrl.Call(m, "PurchaseScheduledInstances", arg0) 18103 ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput) 18104 ret1, _ := ret[1].(error) 18105 return ret0, ret1 18106 } 18107 18108 // PurchaseScheduledInstances indicates an expected call of PurchaseScheduledInstances 18109 func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstances(arg0 interface{}) *gomock.Call { 18110 mr.mock.ctrl.T.Helper() 18111 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstances), arg0) 18112 } 18113 18114 // PurchaseScheduledInstancesWithContext mocks base method 18115 func (m *MockEC2API) PurchaseScheduledInstancesWithContext(arg0 aws.Context, arg1 *ec2.PurchaseScheduledInstancesInput, arg2 ...request.Option) (*ec2.PurchaseScheduledInstancesOutput, error) { 18116 m.ctrl.T.Helper() 18117 varargs := []interface{}{arg0, arg1} 18118 for _, a := range arg2 { 18119 varargs = append(varargs, a) 18120 } 18121 ret := m.ctrl.Call(m, "PurchaseScheduledInstancesWithContext", varargs...) 18122 ret0, _ := ret[0].(*ec2.PurchaseScheduledInstancesOutput) 18123 ret1, _ := ret[1].(error) 18124 return ret0, ret1 18125 } 18126 18127 // PurchaseScheduledInstancesWithContext indicates an expected call of PurchaseScheduledInstancesWithContext 18128 func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18129 mr.mock.ctrl.T.Helper() 18130 varargs := append([]interface{}{arg0, arg1}, arg2...) 18131 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstancesWithContext), varargs...) 18132 } 18133 18134 // PurchaseScheduledInstancesRequest mocks base method 18135 func (m *MockEC2API) PurchaseScheduledInstancesRequest(arg0 *ec2.PurchaseScheduledInstancesInput) (*request.Request, *ec2.PurchaseScheduledInstancesOutput) { 18136 m.ctrl.T.Helper() 18137 ret := m.ctrl.Call(m, "PurchaseScheduledInstancesRequest", arg0) 18138 ret0, _ := ret[0].(*request.Request) 18139 ret1, _ := ret[1].(*ec2.PurchaseScheduledInstancesOutput) 18140 return ret0, ret1 18141 } 18142 18143 // PurchaseScheduledInstancesRequest indicates an expected call of PurchaseScheduledInstancesRequest 18144 func (mr *MockEC2APIMockRecorder) PurchaseScheduledInstancesRequest(arg0 interface{}) *gomock.Call { 18145 mr.mock.ctrl.T.Helper() 18146 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurchaseScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).PurchaseScheduledInstancesRequest), arg0) 18147 } 18148 18149 // RebootInstances mocks base method 18150 func (m *MockEC2API) RebootInstances(arg0 *ec2.RebootInstancesInput) (*ec2.RebootInstancesOutput, error) { 18151 m.ctrl.T.Helper() 18152 ret := m.ctrl.Call(m, "RebootInstances", arg0) 18153 ret0, _ := ret[0].(*ec2.RebootInstancesOutput) 18154 ret1, _ := ret[1].(error) 18155 return ret0, ret1 18156 } 18157 18158 // RebootInstances indicates an expected call of RebootInstances 18159 func (mr *MockEC2APIMockRecorder) RebootInstances(arg0 interface{}) *gomock.Call { 18160 mr.mock.ctrl.T.Helper() 18161 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstances", reflect.TypeOf((*MockEC2API)(nil).RebootInstances), arg0) 18162 } 18163 18164 // RebootInstancesWithContext mocks base method 18165 func (m *MockEC2API) RebootInstancesWithContext(arg0 aws.Context, arg1 *ec2.RebootInstancesInput, arg2 ...request.Option) (*ec2.RebootInstancesOutput, error) { 18166 m.ctrl.T.Helper() 18167 varargs := []interface{}{arg0, arg1} 18168 for _, a := range arg2 { 18169 varargs = append(varargs, a) 18170 } 18171 ret := m.ctrl.Call(m, "RebootInstancesWithContext", varargs...) 18172 ret0, _ := ret[0].(*ec2.RebootInstancesOutput) 18173 ret1, _ := ret[1].(error) 18174 return ret0, ret1 18175 } 18176 18177 // RebootInstancesWithContext indicates an expected call of RebootInstancesWithContext 18178 func (mr *MockEC2APIMockRecorder) RebootInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18179 mr.mock.ctrl.T.Helper() 18180 varargs := append([]interface{}{arg0, arg1}, arg2...) 18181 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RebootInstancesWithContext), varargs...) 18182 } 18183 18184 // RebootInstancesRequest mocks base method 18185 func (m *MockEC2API) RebootInstancesRequest(arg0 *ec2.RebootInstancesInput) (*request.Request, *ec2.RebootInstancesOutput) { 18186 m.ctrl.T.Helper() 18187 ret := m.ctrl.Call(m, "RebootInstancesRequest", arg0) 18188 ret0, _ := ret[0].(*request.Request) 18189 ret1, _ := ret[1].(*ec2.RebootInstancesOutput) 18190 return ret0, ret1 18191 } 18192 18193 // RebootInstancesRequest indicates an expected call of RebootInstancesRequest 18194 func (mr *MockEC2APIMockRecorder) RebootInstancesRequest(arg0 interface{}) *gomock.Call { 18195 mr.mock.ctrl.T.Helper() 18196 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RebootInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RebootInstancesRequest), arg0) 18197 } 18198 18199 // RegisterImage mocks base method 18200 func (m *MockEC2API) RegisterImage(arg0 *ec2.RegisterImageInput) (*ec2.RegisterImageOutput, error) { 18201 m.ctrl.T.Helper() 18202 ret := m.ctrl.Call(m, "RegisterImage", arg0) 18203 ret0, _ := ret[0].(*ec2.RegisterImageOutput) 18204 ret1, _ := ret[1].(error) 18205 return ret0, ret1 18206 } 18207 18208 // RegisterImage indicates an expected call of RegisterImage 18209 func (mr *MockEC2APIMockRecorder) RegisterImage(arg0 interface{}) *gomock.Call { 18210 mr.mock.ctrl.T.Helper() 18211 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImage", reflect.TypeOf((*MockEC2API)(nil).RegisterImage), arg0) 18212 } 18213 18214 // RegisterImageWithContext mocks base method 18215 func (m *MockEC2API) RegisterImageWithContext(arg0 aws.Context, arg1 *ec2.RegisterImageInput, arg2 ...request.Option) (*ec2.RegisterImageOutput, error) { 18216 m.ctrl.T.Helper() 18217 varargs := []interface{}{arg0, arg1} 18218 for _, a := range arg2 { 18219 varargs = append(varargs, a) 18220 } 18221 ret := m.ctrl.Call(m, "RegisterImageWithContext", varargs...) 18222 ret0, _ := ret[0].(*ec2.RegisterImageOutput) 18223 ret1, _ := ret[1].(error) 18224 return ret0, ret1 18225 } 18226 18227 // RegisterImageWithContext indicates an expected call of RegisterImageWithContext 18228 func (mr *MockEC2APIMockRecorder) RegisterImageWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18229 mr.mock.ctrl.T.Helper() 18230 varargs := append([]interface{}{arg0, arg1}, arg2...) 18231 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImageWithContext", reflect.TypeOf((*MockEC2API)(nil).RegisterImageWithContext), varargs...) 18232 } 18233 18234 // RegisterImageRequest mocks base method 18235 func (m *MockEC2API) RegisterImageRequest(arg0 *ec2.RegisterImageInput) (*request.Request, *ec2.RegisterImageOutput) { 18236 m.ctrl.T.Helper() 18237 ret := m.ctrl.Call(m, "RegisterImageRequest", arg0) 18238 ret0, _ := ret[0].(*request.Request) 18239 ret1, _ := ret[1].(*ec2.RegisterImageOutput) 18240 return ret0, ret1 18241 } 18242 18243 // RegisterImageRequest indicates an expected call of RegisterImageRequest 18244 func (mr *MockEC2APIMockRecorder) RegisterImageRequest(arg0 interface{}) *gomock.Call { 18245 mr.mock.ctrl.T.Helper() 18246 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterImageRequest", reflect.TypeOf((*MockEC2API)(nil).RegisterImageRequest), arg0) 18247 } 18248 18249 // RejectTransitGatewayVpcAttachment mocks base method 18250 func (m *MockEC2API) RejectTransitGatewayVpcAttachment(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) { 18251 m.ctrl.T.Helper() 18252 ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachment", arg0) 18253 ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput) 18254 ret1, _ := ret[1].(error) 18255 return ret0, ret1 18256 } 18257 18258 // RejectTransitGatewayVpcAttachment indicates an expected call of RejectTransitGatewayVpcAttachment 18259 func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachment(arg0 interface{}) *gomock.Call { 18260 mr.mock.ctrl.T.Helper() 18261 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachment", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachment), arg0) 18262 } 18263 18264 // RejectTransitGatewayVpcAttachmentWithContext mocks base method 18265 func (m *MockEC2API) RejectTransitGatewayVpcAttachmentWithContext(arg0 aws.Context, arg1 *ec2.RejectTransitGatewayVpcAttachmentInput, arg2 ...request.Option) (*ec2.RejectTransitGatewayVpcAttachmentOutput, error) { 18266 m.ctrl.T.Helper() 18267 varargs := []interface{}{arg0, arg1} 18268 for _, a := range arg2 { 18269 varargs = append(varargs, a) 18270 } 18271 ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentWithContext", varargs...) 18272 ret0, _ := ret[0].(*ec2.RejectTransitGatewayVpcAttachmentOutput) 18273 ret1, _ := ret[1].(error) 18274 return ret0, ret1 18275 } 18276 18277 // RejectTransitGatewayVpcAttachmentWithContext indicates an expected call of RejectTransitGatewayVpcAttachmentWithContext 18278 func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachmentWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18279 mr.mock.ctrl.T.Helper() 18280 varargs := append([]interface{}{arg0, arg1}, arg2...) 18281 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachmentWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentWithContext), varargs...) 18282 } 18283 18284 // RejectTransitGatewayVpcAttachmentRequest mocks base method 18285 func (m *MockEC2API) RejectTransitGatewayVpcAttachmentRequest(arg0 *ec2.RejectTransitGatewayVpcAttachmentInput) (*request.Request, *ec2.RejectTransitGatewayVpcAttachmentOutput) { 18286 m.ctrl.T.Helper() 18287 ret := m.ctrl.Call(m, "RejectTransitGatewayVpcAttachmentRequest", arg0) 18288 ret0, _ := ret[0].(*request.Request) 18289 ret1, _ := ret[1].(*ec2.RejectTransitGatewayVpcAttachmentOutput) 18290 return ret0, ret1 18291 } 18292 18293 // RejectTransitGatewayVpcAttachmentRequest indicates an expected call of RejectTransitGatewayVpcAttachmentRequest 18294 func (mr *MockEC2APIMockRecorder) RejectTransitGatewayVpcAttachmentRequest(arg0 interface{}) *gomock.Call { 18295 mr.mock.ctrl.T.Helper() 18296 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectTransitGatewayVpcAttachmentRequest", reflect.TypeOf((*MockEC2API)(nil).RejectTransitGatewayVpcAttachmentRequest), arg0) 18297 } 18298 18299 // RejectVpcEndpointConnections mocks base method 18300 func (m *MockEC2API) RejectVpcEndpointConnections(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*ec2.RejectVpcEndpointConnectionsOutput, error) { 18301 m.ctrl.T.Helper() 18302 ret := m.ctrl.Call(m, "RejectVpcEndpointConnections", arg0) 18303 ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput) 18304 ret1, _ := ret[1].(error) 18305 return ret0, ret1 18306 } 18307 18308 // RejectVpcEndpointConnections indicates an expected call of RejectVpcEndpointConnections 18309 func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnections(arg0 interface{}) *gomock.Call { 18310 mr.mock.ctrl.T.Helper() 18311 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnections", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnections), arg0) 18312 } 18313 18314 // RejectVpcEndpointConnectionsWithContext mocks base method 18315 func (m *MockEC2API) RejectVpcEndpointConnectionsWithContext(arg0 aws.Context, arg1 *ec2.RejectVpcEndpointConnectionsInput, arg2 ...request.Option) (*ec2.RejectVpcEndpointConnectionsOutput, error) { 18316 m.ctrl.T.Helper() 18317 varargs := []interface{}{arg0, arg1} 18318 for _, a := range arg2 { 18319 varargs = append(varargs, a) 18320 } 18321 ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsWithContext", varargs...) 18322 ret0, _ := ret[0].(*ec2.RejectVpcEndpointConnectionsOutput) 18323 ret1, _ := ret[1].(error) 18324 return ret0, ret1 18325 } 18326 18327 // RejectVpcEndpointConnectionsWithContext indicates an expected call of RejectVpcEndpointConnectionsWithContext 18328 func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18329 mr.mock.ctrl.T.Helper() 18330 varargs := append([]interface{}{arg0, arg1}, arg2...) 18331 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnectionsWithContext), varargs...) 18332 } 18333 18334 // RejectVpcEndpointConnectionsRequest mocks base method 18335 func (m *MockEC2API) RejectVpcEndpointConnectionsRequest(arg0 *ec2.RejectVpcEndpointConnectionsInput) (*request.Request, *ec2.RejectVpcEndpointConnectionsOutput) { 18336 m.ctrl.T.Helper() 18337 ret := m.ctrl.Call(m, "RejectVpcEndpointConnectionsRequest", arg0) 18338 ret0, _ := ret[0].(*request.Request) 18339 ret1, _ := ret[1].(*ec2.RejectVpcEndpointConnectionsOutput) 18340 return ret0, ret1 18341 } 18342 18343 // RejectVpcEndpointConnectionsRequest indicates an expected call of RejectVpcEndpointConnectionsRequest 18344 func (mr *MockEC2APIMockRecorder) RejectVpcEndpointConnectionsRequest(arg0 interface{}) *gomock.Call { 18345 mr.mock.ctrl.T.Helper() 18346 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcEndpointConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcEndpointConnectionsRequest), arg0) 18347 } 18348 18349 // RejectVpcPeeringConnection mocks base method 18350 func (m *MockEC2API) RejectVpcPeeringConnection(arg0 *ec2.RejectVpcPeeringConnectionInput) (*ec2.RejectVpcPeeringConnectionOutput, error) { 18351 m.ctrl.T.Helper() 18352 ret := m.ctrl.Call(m, "RejectVpcPeeringConnection", arg0) 18353 ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput) 18354 ret1, _ := ret[1].(error) 18355 return ret0, ret1 18356 } 18357 18358 // RejectVpcPeeringConnection indicates an expected call of RejectVpcPeeringConnection 18359 func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnection(arg0 interface{}) *gomock.Call { 18360 mr.mock.ctrl.T.Helper() 18361 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnection", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnection), arg0) 18362 } 18363 18364 // RejectVpcPeeringConnectionWithContext mocks base method 18365 func (m *MockEC2API) RejectVpcPeeringConnectionWithContext(arg0 aws.Context, arg1 *ec2.RejectVpcPeeringConnectionInput, arg2 ...request.Option) (*ec2.RejectVpcPeeringConnectionOutput, error) { 18366 m.ctrl.T.Helper() 18367 varargs := []interface{}{arg0, arg1} 18368 for _, a := range arg2 { 18369 varargs = append(varargs, a) 18370 } 18371 ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionWithContext", varargs...) 18372 ret0, _ := ret[0].(*ec2.RejectVpcPeeringConnectionOutput) 18373 ret1, _ := ret[1].(error) 18374 return ret0, ret1 18375 } 18376 18377 // RejectVpcPeeringConnectionWithContext indicates an expected call of RejectVpcPeeringConnectionWithContext 18378 func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnectionWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18379 mr.mock.ctrl.T.Helper() 18380 varargs := append([]interface{}{arg0, arg1}, arg2...) 18381 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnectionWithContext", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnectionWithContext), varargs...) 18382 } 18383 18384 // RejectVpcPeeringConnectionRequest mocks base method 18385 func (m *MockEC2API) RejectVpcPeeringConnectionRequest(arg0 *ec2.RejectVpcPeeringConnectionInput) (*request.Request, *ec2.RejectVpcPeeringConnectionOutput) { 18386 m.ctrl.T.Helper() 18387 ret := m.ctrl.Call(m, "RejectVpcPeeringConnectionRequest", arg0) 18388 ret0, _ := ret[0].(*request.Request) 18389 ret1, _ := ret[1].(*ec2.RejectVpcPeeringConnectionOutput) 18390 return ret0, ret1 18391 } 18392 18393 // RejectVpcPeeringConnectionRequest indicates an expected call of RejectVpcPeeringConnectionRequest 18394 func (mr *MockEC2APIMockRecorder) RejectVpcPeeringConnectionRequest(arg0 interface{}) *gomock.Call { 18395 mr.mock.ctrl.T.Helper() 18396 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RejectVpcPeeringConnectionRequest", reflect.TypeOf((*MockEC2API)(nil).RejectVpcPeeringConnectionRequest), arg0) 18397 } 18398 18399 // ReleaseAddress mocks base method 18400 func (m *MockEC2API) ReleaseAddress(arg0 *ec2.ReleaseAddressInput) (*ec2.ReleaseAddressOutput, error) { 18401 m.ctrl.T.Helper() 18402 ret := m.ctrl.Call(m, "ReleaseAddress", arg0) 18403 ret0, _ := ret[0].(*ec2.ReleaseAddressOutput) 18404 ret1, _ := ret[1].(error) 18405 return ret0, ret1 18406 } 18407 18408 // ReleaseAddress indicates an expected call of ReleaseAddress 18409 func (mr *MockEC2APIMockRecorder) ReleaseAddress(arg0 interface{}) *gomock.Call { 18410 mr.mock.ctrl.T.Helper() 18411 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddress", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddress), arg0) 18412 } 18413 18414 // ReleaseAddressWithContext mocks base method 18415 func (m *MockEC2API) ReleaseAddressWithContext(arg0 aws.Context, arg1 *ec2.ReleaseAddressInput, arg2 ...request.Option) (*ec2.ReleaseAddressOutput, error) { 18416 m.ctrl.T.Helper() 18417 varargs := []interface{}{arg0, arg1} 18418 for _, a := range arg2 { 18419 varargs = append(varargs, a) 18420 } 18421 ret := m.ctrl.Call(m, "ReleaseAddressWithContext", varargs...) 18422 ret0, _ := ret[0].(*ec2.ReleaseAddressOutput) 18423 ret1, _ := ret[1].(error) 18424 return ret0, ret1 18425 } 18426 18427 // ReleaseAddressWithContext indicates an expected call of ReleaseAddressWithContext 18428 func (mr *MockEC2APIMockRecorder) ReleaseAddressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18429 mr.mock.ctrl.T.Helper() 18430 varargs := append([]interface{}{arg0, arg1}, arg2...) 18431 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddressWithContext", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddressWithContext), varargs...) 18432 } 18433 18434 // ReleaseAddressRequest mocks base method 18435 func (m *MockEC2API) ReleaseAddressRequest(arg0 *ec2.ReleaseAddressInput) (*request.Request, *ec2.ReleaseAddressOutput) { 18436 m.ctrl.T.Helper() 18437 ret := m.ctrl.Call(m, "ReleaseAddressRequest", arg0) 18438 ret0, _ := ret[0].(*request.Request) 18439 ret1, _ := ret[1].(*ec2.ReleaseAddressOutput) 18440 return ret0, ret1 18441 } 18442 18443 // ReleaseAddressRequest indicates an expected call of ReleaseAddressRequest 18444 func (mr *MockEC2APIMockRecorder) ReleaseAddressRequest(arg0 interface{}) *gomock.Call { 18445 mr.mock.ctrl.T.Helper() 18446 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseAddressRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseAddressRequest), arg0) 18447 } 18448 18449 // ReleaseHosts mocks base method 18450 func (m *MockEC2API) ReleaseHosts(arg0 *ec2.ReleaseHostsInput) (*ec2.ReleaseHostsOutput, error) { 18451 m.ctrl.T.Helper() 18452 ret := m.ctrl.Call(m, "ReleaseHosts", arg0) 18453 ret0, _ := ret[0].(*ec2.ReleaseHostsOutput) 18454 ret1, _ := ret[1].(error) 18455 return ret0, ret1 18456 } 18457 18458 // ReleaseHosts indicates an expected call of ReleaseHosts 18459 func (mr *MockEC2APIMockRecorder) ReleaseHosts(arg0 interface{}) *gomock.Call { 18460 mr.mock.ctrl.T.Helper() 18461 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHosts", reflect.TypeOf((*MockEC2API)(nil).ReleaseHosts), arg0) 18462 } 18463 18464 // ReleaseHostsWithContext mocks base method 18465 func (m *MockEC2API) ReleaseHostsWithContext(arg0 aws.Context, arg1 *ec2.ReleaseHostsInput, arg2 ...request.Option) (*ec2.ReleaseHostsOutput, error) { 18466 m.ctrl.T.Helper() 18467 varargs := []interface{}{arg0, arg1} 18468 for _, a := range arg2 { 18469 varargs = append(varargs, a) 18470 } 18471 ret := m.ctrl.Call(m, "ReleaseHostsWithContext", varargs...) 18472 ret0, _ := ret[0].(*ec2.ReleaseHostsOutput) 18473 ret1, _ := ret[1].(error) 18474 return ret0, ret1 18475 } 18476 18477 // ReleaseHostsWithContext indicates an expected call of ReleaseHostsWithContext 18478 func (mr *MockEC2APIMockRecorder) ReleaseHostsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18479 mr.mock.ctrl.T.Helper() 18480 varargs := append([]interface{}{arg0, arg1}, arg2...) 18481 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHostsWithContext", reflect.TypeOf((*MockEC2API)(nil).ReleaseHostsWithContext), varargs...) 18482 } 18483 18484 // ReleaseHostsRequest mocks base method 18485 func (m *MockEC2API) ReleaseHostsRequest(arg0 *ec2.ReleaseHostsInput) (*request.Request, *ec2.ReleaseHostsOutput) { 18486 m.ctrl.T.Helper() 18487 ret := m.ctrl.Call(m, "ReleaseHostsRequest", arg0) 18488 ret0, _ := ret[0].(*request.Request) 18489 ret1, _ := ret[1].(*ec2.ReleaseHostsOutput) 18490 return ret0, ret1 18491 } 18492 18493 // ReleaseHostsRequest indicates an expected call of ReleaseHostsRequest 18494 func (mr *MockEC2APIMockRecorder) ReleaseHostsRequest(arg0 interface{}) *gomock.Call { 18495 mr.mock.ctrl.T.Helper() 18496 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseHostsRequest", reflect.TypeOf((*MockEC2API)(nil).ReleaseHostsRequest), arg0) 18497 } 18498 18499 // ReplaceIamInstanceProfileAssociation mocks base method 18500 func (m *MockEC2API) ReplaceIamInstanceProfileAssociation(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) { 18501 m.ctrl.T.Helper() 18502 ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociation", arg0) 18503 ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput) 18504 ret1, _ := ret[1].(error) 18505 return ret0, ret1 18506 } 18507 18508 // ReplaceIamInstanceProfileAssociation indicates an expected call of ReplaceIamInstanceProfileAssociation 18509 func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociation(arg0 interface{}) *gomock.Call { 18510 mr.mock.ctrl.T.Helper() 18511 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociation), arg0) 18512 } 18513 18514 // ReplaceIamInstanceProfileAssociationWithContext mocks base method 18515 func (m *MockEC2API) ReplaceIamInstanceProfileAssociationWithContext(arg0 aws.Context, arg1 *ec2.ReplaceIamInstanceProfileAssociationInput, arg2 ...request.Option) (*ec2.ReplaceIamInstanceProfileAssociationOutput, error) { 18516 m.ctrl.T.Helper() 18517 varargs := []interface{}{arg0, arg1} 18518 for _, a := range arg2 { 18519 varargs = append(varargs, a) 18520 } 18521 ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationWithContext", varargs...) 18522 ret0, _ := ret[0].(*ec2.ReplaceIamInstanceProfileAssociationOutput) 18523 ret1, _ := ret[1].(error) 18524 return ret0, ret1 18525 } 18526 18527 // ReplaceIamInstanceProfileAssociationWithContext indicates an expected call of ReplaceIamInstanceProfileAssociationWithContext 18528 func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18529 mr.mock.ctrl.T.Helper() 18530 varargs := append([]interface{}{arg0, arg1}, arg2...) 18531 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationWithContext), varargs...) 18532 } 18533 18534 // ReplaceIamInstanceProfileAssociationRequest mocks base method 18535 func (m *MockEC2API) ReplaceIamInstanceProfileAssociationRequest(arg0 *ec2.ReplaceIamInstanceProfileAssociationInput) (*request.Request, *ec2.ReplaceIamInstanceProfileAssociationOutput) { 18536 m.ctrl.T.Helper() 18537 ret := m.ctrl.Call(m, "ReplaceIamInstanceProfileAssociationRequest", arg0) 18538 ret0, _ := ret[0].(*request.Request) 18539 ret1, _ := ret[1].(*ec2.ReplaceIamInstanceProfileAssociationOutput) 18540 return ret0, ret1 18541 } 18542 18543 // ReplaceIamInstanceProfileAssociationRequest indicates an expected call of ReplaceIamInstanceProfileAssociationRequest 18544 func (mr *MockEC2APIMockRecorder) ReplaceIamInstanceProfileAssociationRequest(arg0 interface{}) *gomock.Call { 18545 mr.mock.ctrl.T.Helper() 18546 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceIamInstanceProfileAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceIamInstanceProfileAssociationRequest), arg0) 18547 } 18548 18549 // ReplaceNetworkAclAssociation mocks base method 18550 func (m *MockEC2API) ReplaceNetworkAclAssociation(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*ec2.ReplaceNetworkAclAssociationOutput, error) { 18551 m.ctrl.T.Helper() 18552 ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociation", arg0) 18553 ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput) 18554 ret1, _ := ret[1].(error) 18555 return ret0, ret1 18556 } 18557 18558 // ReplaceNetworkAclAssociation indicates an expected call of ReplaceNetworkAclAssociation 18559 func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociation(arg0 interface{}) *gomock.Call { 18560 mr.mock.ctrl.T.Helper() 18561 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociation), arg0) 18562 } 18563 18564 // ReplaceNetworkAclAssociationWithContext mocks base method 18565 func (m *MockEC2API) ReplaceNetworkAclAssociationWithContext(arg0 aws.Context, arg1 *ec2.ReplaceNetworkAclAssociationInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclAssociationOutput, error) { 18566 m.ctrl.T.Helper() 18567 varargs := []interface{}{arg0, arg1} 18568 for _, a := range arg2 { 18569 varargs = append(varargs, a) 18570 } 18571 ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationWithContext", varargs...) 18572 ret0, _ := ret[0].(*ec2.ReplaceNetworkAclAssociationOutput) 18573 ret1, _ := ret[1].(error) 18574 return ret0, ret1 18575 } 18576 18577 // ReplaceNetworkAclAssociationWithContext indicates an expected call of ReplaceNetworkAclAssociationWithContext 18578 func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18579 mr.mock.ctrl.T.Helper() 18580 varargs := append([]interface{}{arg0, arg1}, arg2...) 18581 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociationWithContext), varargs...) 18582 } 18583 18584 // ReplaceNetworkAclAssociationRequest mocks base method 18585 func (m *MockEC2API) ReplaceNetworkAclAssociationRequest(arg0 *ec2.ReplaceNetworkAclAssociationInput) (*request.Request, *ec2.ReplaceNetworkAclAssociationOutput) { 18586 m.ctrl.T.Helper() 18587 ret := m.ctrl.Call(m, "ReplaceNetworkAclAssociationRequest", arg0) 18588 ret0, _ := ret[0].(*request.Request) 18589 ret1, _ := ret[1].(*ec2.ReplaceNetworkAclAssociationOutput) 18590 return ret0, ret1 18591 } 18592 18593 // ReplaceNetworkAclAssociationRequest indicates an expected call of ReplaceNetworkAclAssociationRequest 18594 func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclAssociationRequest(arg0 interface{}) *gomock.Call { 18595 mr.mock.ctrl.T.Helper() 18596 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclAssociationRequest), arg0) 18597 } 18598 18599 // ReplaceNetworkAclEntry mocks base method 18600 func (m *MockEC2API) ReplaceNetworkAclEntry(arg0 *ec2.ReplaceNetworkAclEntryInput) (*ec2.ReplaceNetworkAclEntryOutput, error) { 18601 m.ctrl.T.Helper() 18602 ret := m.ctrl.Call(m, "ReplaceNetworkAclEntry", arg0) 18603 ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput) 18604 ret1, _ := ret[1].(error) 18605 return ret0, ret1 18606 } 18607 18608 // ReplaceNetworkAclEntry indicates an expected call of ReplaceNetworkAclEntry 18609 func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntry(arg0 interface{}) *gomock.Call { 18610 mr.mock.ctrl.T.Helper() 18611 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntry", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntry), arg0) 18612 } 18613 18614 // ReplaceNetworkAclEntryWithContext mocks base method 18615 func (m *MockEC2API) ReplaceNetworkAclEntryWithContext(arg0 aws.Context, arg1 *ec2.ReplaceNetworkAclEntryInput, arg2 ...request.Option) (*ec2.ReplaceNetworkAclEntryOutput, error) { 18616 m.ctrl.T.Helper() 18617 varargs := []interface{}{arg0, arg1} 18618 for _, a := range arg2 { 18619 varargs = append(varargs, a) 18620 } 18621 ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryWithContext", varargs...) 18622 ret0, _ := ret[0].(*ec2.ReplaceNetworkAclEntryOutput) 18623 ret1, _ := ret[1].(error) 18624 return ret0, ret1 18625 } 18626 18627 // ReplaceNetworkAclEntryWithContext indicates an expected call of ReplaceNetworkAclEntryWithContext 18628 func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntryWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18629 mr.mock.ctrl.T.Helper() 18630 varargs := append([]interface{}{arg0, arg1}, arg2...) 18631 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntryWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntryWithContext), varargs...) 18632 } 18633 18634 // ReplaceNetworkAclEntryRequest mocks base method 18635 func (m *MockEC2API) ReplaceNetworkAclEntryRequest(arg0 *ec2.ReplaceNetworkAclEntryInput) (*request.Request, *ec2.ReplaceNetworkAclEntryOutput) { 18636 m.ctrl.T.Helper() 18637 ret := m.ctrl.Call(m, "ReplaceNetworkAclEntryRequest", arg0) 18638 ret0, _ := ret[0].(*request.Request) 18639 ret1, _ := ret[1].(*ec2.ReplaceNetworkAclEntryOutput) 18640 return ret0, ret1 18641 } 18642 18643 // ReplaceNetworkAclEntryRequest indicates an expected call of ReplaceNetworkAclEntryRequest 18644 func (mr *MockEC2APIMockRecorder) ReplaceNetworkAclEntryRequest(arg0 interface{}) *gomock.Call { 18645 mr.mock.ctrl.T.Helper() 18646 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceNetworkAclEntryRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceNetworkAclEntryRequest), arg0) 18647 } 18648 18649 // ReplaceRoute mocks base method 18650 func (m *MockEC2API) ReplaceRoute(arg0 *ec2.ReplaceRouteInput) (*ec2.ReplaceRouteOutput, error) { 18651 m.ctrl.T.Helper() 18652 ret := m.ctrl.Call(m, "ReplaceRoute", arg0) 18653 ret0, _ := ret[0].(*ec2.ReplaceRouteOutput) 18654 ret1, _ := ret[1].(error) 18655 return ret0, ret1 18656 } 18657 18658 // ReplaceRoute indicates an expected call of ReplaceRoute 18659 func (mr *MockEC2APIMockRecorder) ReplaceRoute(arg0 interface{}) *gomock.Call { 18660 mr.mock.ctrl.T.Helper() 18661 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceRoute), arg0) 18662 } 18663 18664 // ReplaceRouteWithContext mocks base method 18665 func (m *MockEC2API) ReplaceRouteWithContext(arg0 aws.Context, arg1 *ec2.ReplaceRouteInput, arg2 ...request.Option) (*ec2.ReplaceRouteOutput, error) { 18666 m.ctrl.T.Helper() 18667 varargs := []interface{}{arg0, arg1} 18668 for _, a := range arg2 { 18669 varargs = append(varargs, a) 18670 } 18671 ret := m.ctrl.Call(m, "ReplaceRouteWithContext", varargs...) 18672 ret0, _ := ret[0].(*ec2.ReplaceRouteOutput) 18673 ret1, _ := ret[1].(error) 18674 return ret0, ret1 18675 } 18676 18677 // ReplaceRouteWithContext indicates an expected call of ReplaceRouteWithContext 18678 func (mr *MockEC2APIMockRecorder) ReplaceRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18679 mr.mock.ctrl.T.Helper() 18680 varargs := append([]interface{}{arg0, arg1}, arg2...) 18681 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteWithContext), varargs...) 18682 } 18683 18684 // ReplaceRouteRequest mocks base method 18685 func (m *MockEC2API) ReplaceRouteRequest(arg0 *ec2.ReplaceRouteInput) (*request.Request, *ec2.ReplaceRouteOutput) { 18686 m.ctrl.T.Helper() 18687 ret := m.ctrl.Call(m, "ReplaceRouteRequest", arg0) 18688 ret0, _ := ret[0].(*request.Request) 18689 ret1, _ := ret[1].(*ec2.ReplaceRouteOutput) 18690 return ret0, ret1 18691 } 18692 18693 // ReplaceRouteRequest indicates an expected call of ReplaceRouteRequest 18694 func (mr *MockEC2APIMockRecorder) ReplaceRouteRequest(arg0 interface{}) *gomock.Call { 18695 mr.mock.ctrl.T.Helper() 18696 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteRequest), arg0) 18697 } 18698 18699 // ReplaceRouteTableAssociation mocks base method 18700 func (m *MockEC2API) ReplaceRouteTableAssociation(arg0 *ec2.ReplaceRouteTableAssociationInput) (*ec2.ReplaceRouteTableAssociationOutput, error) { 18701 m.ctrl.T.Helper() 18702 ret := m.ctrl.Call(m, "ReplaceRouteTableAssociation", arg0) 18703 ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput) 18704 ret1, _ := ret[1].(error) 18705 return ret0, ret1 18706 } 18707 18708 // ReplaceRouteTableAssociation indicates an expected call of ReplaceRouteTableAssociation 18709 func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociation(arg0 interface{}) *gomock.Call { 18710 mr.mock.ctrl.T.Helper() 18711 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociation", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociation), arg0) 18712 } 18713 18714 // ReplaceRouteTableAssociationWithContext mocks base method 18715 func (m *MockEC2API) ReplaceRouteTableAssociationWithContext(arg0 aws.Context, arg1 *ec2.ReplaceRouteTableAssociationInput, arg2 ...request.Option) (*ec2.ReplaceRouteTableAssociationOutput, error) { 18716 m.ctrl.T.Helper() 18717 varargs := []interface{}{arg0, arg1} 18718 for _, a := range arg2 { 18719 varargs = append(varargs, a) 18720 } 18721 ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationWithContext", varargs...) 18722 ret0, _ := ret[0].(*ec2.ReplaceRouteTableAssociationOutput) 18723 ret1, _ := ret[1].(error) 18724 return ret0, ret1 18725 } 18726 18727 // ReplaceRouteTableAssociationWithContext indicates an expected call of ReplaceRouteTableAssociationWithContext 18728 func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociationWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18729 mr.mock.ctrl.T.Helper() 18730 varargs := append([]interface{}{arg0, arg1}, arg2...) 18731 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociationWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociationWithContext), varargs...) 18732 } 18733 18734 // ReplaceRouteTableAssociationRequest mocks base method 18735 func (m *MockEC2API) ReplaceRouteTableAssociationRequest(arg0 *ec2.ReplaceRouteTableAssociationInput) (*request.Request, *ec2.ReplaceRouteTableAssociationOutput) { 18736 m.ctrl.T.Helper() 18737 ret := m.ctrl.Call(m, "ReplaceRouteTableAssociationRequest", arg0) 18738 ret0, _ := ret[0].(*request.Request) 18739 ret1, _ := ret[1].(*ec2.ReplaceRouteTableAssociationOutput) 18740 return ret0, ret1 18741 } 18742 18743 // ReplaceRouteTableAssociationRequest indicates an expected call of ReplaceRouteTableAssociationRequest 18744 func (mr *MockEC2APIMockRecorder) ReplaceRouteTableAssociationRequest(arg0 interface{}) *gomock.Call { 18745 mr.mock.ctrl.T.Helper() 18746 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceRouteTableAssociationRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceRouteTableAssociationRequest), arg0) 18747 } 18748 18749 // ReplaceTransitGatewayRoute mocks base method 18750 func (m *MockEC2API) ReplaceTransitGatewayRoute(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*ec2.ReplaceTransitGatewayRouteOutput, error) { 18751 m.ctrl.T.Helper() 18752 ret := m.ctrl.Call(m, "ReplaceTransitGatewayRoute", arg0) 18753 ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput) 18754 ret1, _ := ret[1].(error) 18755 return ret0, ret1 18756 } 18757 18758 // ReplaceTransitGatewayRoute indicates an expected call of ReplaceTransitGatewayRoute 18759 func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRoute(arg0 interface{}) *gomock.Call { 18760 mr.mock.ctrl.T.Helper() 18761 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRoute", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRoute), arg0) 18762 } 18763 18764 // ReplaceTransitGatewayRouteWithContext mocks base method 18765 func (m *MockEC2API) ReplaceTransitGatewayRouteWithContext(arg0 aws.Context, arg1 *ec2.ReplaceTransitGatewayRouteInput, arg2 ...request.Option) (*ec2.ReplaceTransitGatewayRouteOutput, error) { 18766 m.ctrl.T.Helper() 18767 varargs := []interface{}{arg0, arg1} 18768 for _, a := range arg2 { 18769 varargs = append(varargs, a) 18770 } 18771 ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteWithContext", varargs...) 18772 ret0, _ := ret[0].(*ec2.ReplaceTransitGatewayRouteOutput) 18773 ret1, _ := ret[1].(error) 18774 return ret0, ret1 18775 } 18776 18777 // ReplaceTransitGatewayRouteWithContext indicates an expected call of ReplaceTransitGatewayRouteWithContext 18778 func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18779 mr.mock.ctrl.T.Helper() 18780 varargs := append([]interface{}{arg0, arg1}, arg2...) 18781 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteWithContext", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteWithContext), varargs...) 18782 } 18783 18784 // ReplaceTransitGatewayRouteRequest mocks base method 18785 func (m *MockEC2API) ReplaceTransitGatewayRouteRequest(arg0 *ec2.ReplaceTransitGatewayRouteInput) (*request.Request, *ec2.ReplaceTransitGatewayRouteOutput) { 18786 m.ctrl.T.Helper() 18787 ret := m.ctrl.Call(m, "ReplaceTransitGatewayRouteRequest", arg0) 18788 ret0, _ := ret[0].(*request.Request) 18789 ret1, _ := ret[1].(*ec2.ReplaceTransitGatewayRouteOutput) 18790 return ret0, ret1 18791 } 18792 18793 // ReplaceTransitGatewayRouteRequest indicates an expected call of ReplaceTransitGatewayRouteRequest 18794 func (mr *MockEC2APIMockRecorder) ReplaceTransitGatewayRouteRequest(arg0 interface{}) *gomock.Call { 18795 mr.mock.ctrl.T.Helper() 18796 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceTransitGatewayRouteRequest", reflect.TypeOf((*MockEC2API)(nil).ReplaceTransitGatewayRouteRequest), arg0) 18797 } 18798 18799 // ReportInstanceStatus mocks base method 18800 func (m *MockEC2API) ReportInstanceStatus(arg0 *ec2.ReportInstanceStatusInput) (*ec2.ReportInstanceStatusOutput, error) { 18801 m.ctrl.T.Helper() 18802 ret := m.ctrl.Call(m, "ReportInstanceStatus", arg0) 18803 ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput) 18804 ret1, _ := ret[1].(error) 18805 return ret0, ret1 18806 } 18807 18808 // ReportInstanceStatus indicates an expected call of ReportInstanceStatus 18809 func (mr *MockEC2APIMockRecorder) ReportInstanceStatus(arg0 interface{}) *gomock.Call { 18810 mr.mock.ctrl.T.Helper() 18811 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatus", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatus), arg0) 18812 } 18813 18814 // ReportInstanceStatusWithContext mocks base method 18815 func (m *MockEC2API) ReportInstanceStatusWithContext(arg0 aws.Context, arg1 *ec2.ReportInstanceStatusInput, arg2 ...request.Option) (*ec2.ReportInstanceStatusOutput, error) { 18816 m.ctrl.T.Helper() 18817 varargs := []interface{}{arg0, arg1} 18818 for _, a := range arg2 { 18819 varargs = append(varargs, a) 18820 } 18821 ret := m.ctrl.Call(m, "ReportInstanceStatusWithContext", varargs...) 18822 ret0, _ := ret[0].(*ec2.ReportInstanceStatusOutput) 18823 ret1, _ := ret[1].(error) 18824 return ret0, ret1 18825 } 18826 18827 // ReportInstanceStatusWithContext indicates an expected call of ReportInstanceStatusWithContext 18828 func (mr *MockEC2APIMockRecorder) ReportInstanceStatusWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18829 mr.mock.ctrl.T.Helper() 18830 varargs := append([]interface{}{arg0, arg1}, arg2...) 18831 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatusWithContext", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatusWithContext), varargs...) 18832 } 18833 18834 // ReportInstanceStatusRequest mocks base method 18835 func (m *MockEC2API) ReportInstanceStatusRequest(arg0 *ec2.ReportInstanceStatusInput) (*request.Request, *ec2.ReportInstanceStatusOutput) { 18836 m.ctrl.T.Helper() 18837 ret := m.ctrl.Call(m, "ReportInstanceStatusRequest", arg0) 18838 ret0, _ := ret[0].(*request.Request) 18839 ret1, _ := ret[1].(*ec2.ReportInstanceStatusOutput) 18840 return ret0, ret1 18841 } 18842 18843 // ReportInstanceStatusRequest indicates an expected call of ReportInstanceStatusRequest 18844 func (mr *MockEC2APIMockRecorder) ReportInstanceStatusRequest(arg0 interface{}) *gomock.Call { 18845 mr.mock.ctrl.T.Helper() 18846 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportInstanceStatusRequest", reflect.TypeOf((*MockEC2API)(nil).ReportInstanceStatusRequest), arg0) 18847 } 18848 18849 // RequestSpotFleet mocks base method 18850 func (m *MockEC2API) RequestSpotFleet(arg0 *ec2.RequestSpotFleetInput) (*ec2.RequestSpotFleetOutput, error) { 18851 m.ctrl.T.Helper() 18852 ret := m.ctrl.Call(m, "RequestSpotFleet", arg0) 18853 ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput) 18854 ret1, _ := ret[1].(error) 18855 return ret0, ret1 18856 } 18857 18858 // RequestSpotFleet indicates an expected call of RequestSpotFleet 18859 func (mr *MockEC2APIMockRecorder) RequestSpotFleet(arg0 interface{}) *gomock.Call { 18860 mr.mock.ctrl.T.Helper() 18861 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleet", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleet), arg0) 18862 } 18863 18864 // RequestSpotFleetWithContext mocks base method 18865 func (m *MockEC2API) RequestSpotFleetWithContext(arg0 aws.Context, arg1 *ec2.RequestSpotFleetInput, arg2 ...request.Option) (*ec2.RequestSpotFleetOutput, error) { 18866 m.ctrl.T.Helper() 18867 varargs := []interface{}{arg0, arg1} 18868 for _, a := range arg2 { 18869 varargs = append(varargs, a) 18870 } 18871 ret := m.ctrl.Call(m, "RequestSpotFleetWithContext", varargs...) 18872 ret0, _ := ret[0].(*ec2.RequestSpotFleetOutput) 18873 ret1, _ := ret[1].(error) 18874 return ret0, ret1 18875 } 18876 18877 // RequestSpotFleetWithContext indicates an expected call of RequestSpotFleetWithContext 18878 func (mr *MockEC2APIMockRecorder) RequestSpotFleetWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18879 mr.mock.ctrl.T.Helper() 18880 varargs := append([]interface{}{arg0, arg1}, arg2...) 18881 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleetWithContext", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleetWithContext), varargs...) 18882 } 18883 18884 // RequestSpotFleetRequest mocks base method 18885 func (m *MockEC2API) RequestSpotFleetRequest(arg0 *ec2.RequestSpotFleetInput) (*request.Request, *ec2.RequestSpotFleetOutput) { 18886 m.ctrl.T.Helper() 18887 ret := m.ctrl.Call(m, "RequestSpotFleetRequest", arg0) 18888 ret0, _ := ret[0].(*request.Request) 18889 ret1, _ := ret[1].(*ec2.RequestSpotFleetOutput) 18890 return ret0, ret1 18891 } 18892 18893 // RequestSpotFleetRequest indicates an expected call of RequestSpotFleetRequest 18894 func (mr *MockEC2APIMockRecorder) RequestSpotFleetRequest(arg0 interface{}) *gomock.Call { 18895 mr.mock.ctrl.T.Helper() 18896 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotFleetRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotFleetRequest), arg0) 18897 } 18898 18899 // RequestSpotInstances mocks base method 18900 func (m *MockEC2API) RequestSpotInstances(arg0 *ec2.RequestSpotInstancesInput) (*ec2.RequestSpotInstancesOutput, error) { 18901 m.ctrl.T.Helper() 18902 ret := m.ctrl.Call(m, "RequestSpotInstances", arg0) 18903 ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput) 18904 ret1, _ := ret[1].(error) 18905 return ret0, ret1 18906 } 18907 18908 // RequestSpotInstances indicates an expected call of RequestSpotInstances 18909 func (mr *MockEC2APIMockRecorder) RequestSpotInstances(arg0 interface{}) *gomock.Call { 18910 mr.mock.ctrl.T.Helper() 18911 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstances", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstances), arg0) 18912 } 18913 18914 // RequestSpotInstancesWithContext mocks base method 18915 func (m *MockEC2API) RequestSpotInstancesWithContext(arg0 aws.Context, arg1 *ec2.RequestSpotInstancesInput, arg2 ...request.Option) (*ec2.RequestSpotInstancesOutput, error) { 18916 m.ctrl.T.Helper() 18917 varargs := []interface{}{arg0, arg1} 18918 for _, a := range arg2 { 18919 varargs = append(varargs, a) 18920 } 18921 ret := m.ctrl.Call(m, "RequestSpotInstancesWithContext", varargs...) 18922 ret0, _ := ret[0].(*ec2.RequestSpotInstancesOutput) 18923 ret1, _ := ret[1].(error) 18924 return ret0, ret1 18925 } 18926 18927 // RequestSpotInstancesWithContext indicates an expected call of RequestSpotInstancesWithContext 18928 func (mr *MockEC2APIMockRecorder) RequestSpotInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18929 mr.mock.ctrl.T.Helper() 18930 varargs := append([]interface{}{arg0, arg1}, arg2...) 18931 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesWithContext), varargs...) 18932 } 18933 18934 // RequestSpotInstancesRequest mocks base method 18935 func (m *MockEC2API) RequestSpotInstancesRequest(arg0 *ec2.RequestSpotInstancesInput) (*request.Request, *ec2.RequestSpotInstancesOutput) { 18936 m.ctrl.T.Helper() 18937 ret := m.ctrl.Call(m, "RequestSpotInstancesRequest", arg0) 18938 ret0, _ := ret[0].(*request.Request) 18939 ret1, _ := ret[1].(*ec2.RequestSpotInstancesOutput) 18940 return ret0, ret1 18941 } 18942 18943 // RequestSpotInstancesRequest indicates an expected call of RequestSpotInstancesRequest 18944 func (mr *MockEC2APIMockRecorder) RequestSpotInstancesRequest(arg0 interface{}) *gomock.Call { 18945 mr.mock.ctrl.T.Helper() 18946 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestSpotInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RequestSpotInstancesRequest), arg0) 18947 } 18948 18949 // ResetEbsDefaultKmsKeyId mocks base method 18950 func (m *MockEC2API) ResetEbsDefaultKmsKeyId(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) { 18951 m.ctrl.T.Helper() 18952 ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyId", arg0) 18953 ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput) 18954 ret1, _ := ret[1].(error) 18955 return ret0, ret1 18956 } 18957 18958 // ResetEbsDefaultKmsKeyId indicates an expected call of ResetEbsDefaultKmsKeyId 18959 func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyId(arg0 interface{}) *gomock.Call { 18960 mr.mock.ctrl.T.Helper() 18961 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyId", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyId), arg0) 18962 } 18963 18964 // ResetEbsDefaultKmsKeyIdWithContext mocks base method 18965 func (m *MockEC2API) ResetEbsDefaultKmsKeyIdWithContext(arg0 aws.Context, arg1 *ec2.ResetEbsDefaultKmsKeyIdInput, arg2 ...request.Option) (*ec2.ResetEbsDefaultKmsKeyIdOutput, error) { 18966 m.ctrl.T.Helper() 18967 varargs := []interface{}{arg0, arg1} 18968 for _, a := range arg2 { 18969 varargs = append(varargs, a) 18970 } 18971 ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdWithContext", varargs...) 18972 ret0, _ := ret[0].(*ec2.ResetEbsDefaultKmsKeyIdOutput) 18973 ret1, _ := ret[1].(error) 18974 return ret0, ret1 18975 } 18976 18977 // ResetEbsDefaultKmsKeyIdWithContext indicates an expected call of ResetEbsDefaultKmsKeyIdWithContext 18978 func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyIdWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 18979 mr.mock.ctrl.T.Helper() 18980 varargs := append([]interface{}{arg0, arg1}, arg2...) 18981 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyIdWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdWithContext), varargs...) 18982 } 18983 18984 // ResetEbsDefaultKmsKeyIdRequest mocks base method 18985 func (m *MockEC2API) ResetEbsDefaultKmsKeyIdRequest(arg0 *ec2.ResetEbsDefaultKmsKeyIdInput) (*request.Request, *ec2.ResetEbsDefaultKmsKeyIdOutput) { 18986 m.ctrl.T.Helper() 18987 ret := m.ctrl.Call(m, "ResetEbsDefaultKmsKeyIdRequest", arg0) 18988 ret0, _ := ret[0].(*request.Request) 18989 ret1, _ := ret[1].(*ec2.ResetEbsDefaultKmsKeyIdOutput) 18990 return ret0, ret1 18991 } 18992 18993 // ResetEbsDefaultKmsKeyIdRequest indicates an expected call of ResetEbsDefaultKmsKeyIdRequest 18994 func (mr *MockEC2APIMockRecorder) ResetEbsDefaultKmsKeyIdRequest(arg0 interface{}) *gomock.Call { 18995 mr.mock.ctrl.T.Helper() 18996 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetEbsDefaultKmsKeyIdRequest", reflect.TypeOf((*MockEC2API)(nil).ResetEbsDefaultKmsKeyIdRequest), arg0) 18997 } 18998 18999 // ResetFpgaImageAttribute mocks base method 19000 func (m *MockEC2API) ResetFpgaImageAttribute(arg0 *ec2.ResetFpgaImageAttributeInput) (*ec2.ResetFpgaImageAttributeOutput, error) { 19001 m.ctrl.T.Helper() 19002 ret := m.ctrl.Call(m, "ResetFpgaImageAttribute", arg0) 19003 ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput) 19004 ret1, _ := ret[1].(error) 19005 return ret0, ret1 19006 } 19007 19008 // ResetFpgaImageAttribute indicates an expected call of ResetFpgaImageAttribute 19009 func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttribute(arg0 interface{}) *gomock.Call { 19010 mr.mock.ctrl.T.Helper() 19011 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttribute), arg0) 19012 } 19013 19014 // ResetFpgaImageAttributeWithContext mocks base method 19015 func (m *MockEC2API) ResetFpgaImageAttributeWithContext(arg0 aws.Context, arg1 *ec2.ResetFpgaImageAttributeInput, arg2 ...request.Option) (*ec2.ResetFpgaImageAttributeOutput, error) { 19016 m.ctrl.T.Helper() 19017 varargs := []interface{}{arg0, arg1} 19018 for _, a := range arg2 { 19019 varargs = append(varargs, a) 19020 } 19021 ret := m.ctrl.Call(m, "ResetFpgaImageAttributeWithContext", varargs...) 19022 ret0, _ := ret[0].(*ec2.ResetFpgaImageAttributeOutput) 19023 ret1, _ := ret[1].(error) 19024 return ret0, ret1 19025 } 19026 19027 // ResetFpgaImageAttributeWithContext indicates an expected call of ResetFpgaImageAttributeWithContext 19028 func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19029 mr.mock.ctrl.T.Helper() 19030 varargs := append([]interface{}{arg0, arg1}, arg2...) 19031 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttributeWithContext), varargs...) 19032 } 19033 19034 // ResetFpgaImageAttributeRequest mocks base method 19035 func (m *MockEC2API) ResetFpgaImageAttributeRequest(arg0 *ec2.ResetFpgaImageAttributeInput) (*request.Request, *ec2.ResetFpgaImageAttributeOutput) { 19036 m.ctrl.T.Helper() 19037 ret := m.ctrl.Call(m, "ResetFpgaImageAttributeRequest", arg0) 19038 ret0, _ := ret[0].(*request.Request) 19039 ret1, _ := ret[1].(*ec2.ResetFpgaImageAttributeOutput) 19040 return ret0, ret1 19041 } 19042 19043 // ResetFpgaImageAttributeRequest indicates an expected call of ResetFpgaImageAttributeRequest 19044 func (mr *MockEC2APIMockRecorder) ResetFpgaImageAttributeRequest(arg0 interface{}) *gomock.Call { 19045 mr.mock.ctrl.T.Helper() 19046 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFpgaImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetFpgaImageAttributeRequest), arg0) 19047 } 19048 19049 // ResetImageAttribute mocks base method 19050 func (m *MockEC2API) ResetImageAttribute(arg0 *ec2.ResetImageAttributeInput) (*ec2.ResetImageAttributeOutput, error) { 19051 m.ctrl.T.Helper() 19052 ret := m.ctrl.Call(m, "ResetImageAttribute", arg0) 19053 ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput) 19054 ret1, _ := ret[1].(error) 19055 return ret0, ret1 19056 } 19057 19058 // ResetImageAttribute indicates an expected call of ResetImageAttribute 19059 func (mr *MockEC2APIMockRecorder) ResetImageAttribute(arg0 interface{}) *gomock.Call { 19060 mr.mock.ctrl.T.Helper() 19061 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttribute), arg0) 19062 } 19063 19064 // ResetImageAttributeWithContext mocks base method 19065 func (m *MockEC2API) ResetImageAttributeWithContext(arg0 aws.Context, arg1 *ec2.ResetImageAttributeInput, arg2 ...request.Option) (*ec2.ResetImageAttributeOutput, error) { 19066 m.ctrl.T.Helper() 19067 varargs := []interface{}{arg0, arg1} 19068 for _, a := range arg2 { 19069 varargs = append(varargs, a) 19070 } 19071 ret := m.ctrl.Call(m, "ResetImageAttributeWithContext", varargs...) 19072 ret0, _ := ret[0].(*ec2.ResetImageAttributeOutput) 19073 ret1, _ := ret[1].(error) 19074 return ret0, ret1 19075 } 19076 19077 // ResetImageAttributeWithContext indicates an expected call of ResetImageAttributeWithContext 19078 func (mr *MockEC2APIMockRecorder) ResetImageAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19079 mr.mock.ctrl.T.Helper() 19080 varargs := append([]interface{}{arg0, arg1}, arg2...) 19081 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttributeWithContext), varargs...) 19082 } 19083 19084 // ResetImageAttributeRequest mocks base method 19085 func (m *MockEC2API) ResetImageAttributeRequest(arg0 *ec2.ResetImageAttributeInput) (*request.Request, *ec2.ResetImageAttributeOutput) { 19086 m.ctrl.T.Helper() 19087 ret := m.ctrl.Call(m, "ResetImageAttributeRequest", arg0) 19088 ret0, _ := ret[0].(*request.Request) 19089 ret1, _ := ret[1].(*ec2.ResetImageAttributeOutput) 19090 return ret0, ret1 19091 } 19092 19093 // ResetImageAttributeRequest indicates an expected call of ResetImageAttributeRequest 19094 func (mr *MockEC2APIMockRecorder) ResetImageAttributeRequest(arg0 interface{}) *gomock.Call { 19095 mr.mock.ctrl.T.Helper() 19096 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetImageAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetImageAttributeRequest), arg0) 19097 } 19098 19099 // ResetInstanceAttribute mocks base method 19100 func (m *MockEC2API) ResetInstanceAttribute(arg0 *ec2.ResetInstanceAttributeInput) (*ec2.ResetInstanceAttributeOutput, error) { 19101 m.ctrl.T.Helper() 19102 ret := m.ctrl.Call(m, "ResetInstanceAttribute", arg0) 19103 ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput) 19104 ret1, _ := ret[1].(error) 19105 return ret0, ret1 19106 } 19107 19108 // ResetInstanceAttribute indicates an expected call of ResetInstanceAttribute 19109 func (mr *MockEC2APIMockRecorder) ResetInstanceAttribute(arg0 interface{}) *gomock.Call { 19110 mr.mock.ctrl.T.Helper() 19111 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttribute), arg0) 19112 } 19113 19114 // ResetInstanceAttributeWithContext mocks base method 19115 func (m *MockEC2API) ResetInstanceAttributeWithContext(arg0 aws.Context, arg1 *ec2.ResetInstanceAttributeInput, arg2 ...request.Option) (*ec2.ResetInstanceAttributeOutput, error) { 19116 m.ctrl.T.Helper() 19117 varargs := []interface{}{arg0, arg1} 19118 for _, a := range arg2 { 19119 varargs = append(varargs, a) 19120 } 19121 ret := m.ctrl.Call(m, "ResetInstanceAttributeWithContext", varargs...) 19122 ret0, _ := ret[0].(*ec2.ResetInstanceAttributeOutput) 19123 ret1, _ := ret[1].(error) 19124 return ret0, ret1 19125 } 19126 19127 // ResetInstanceAttributeWithContext indicates an expected call of ResetInstanceAttributeWithContext 19128 func (mr *MockEC2APIMockRecorder) ResetInstanceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19129 mr.mock.ctrl.T.Helper() 19130 varargs := append([]interface{}{arg0, arg1}, arg2...) 19131 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttributeWithContext), varargs...) 19132 } 19133 19134 // ResetInstanceAttributeRequest mocks base method 19135 func (m *MockEC2API) ResetInstanceAttributeRequest(arg0 *ec2.ResetInstanceAttributeInput) (*request.Request, *ec2.ResetInstanceAttributeOutput) { 19136 m.ctrl.T.Helper() 19137 ret := m.ctrl.Call(m, "ResetInstanceAttributeRequest", arg0) 19138 ret0, _ := ret[0].(*request.Request) 19139 ret1, _ := ret[1].(*ec2.ResetInstanceAttributeOutput) 19140 return ret0, ret1 19141 } 19142 19143 // ResetInstanceAttributeRequest indicates an expected call of ResetInstanceAttributeRequest 19144 func (mr *MockEC2APIMockRecorder) ResetInstanceAttributeRequest(arg0 interface{}) *gomock.Call { 19145 mr.mock.ctrl.T.Helper() 19146 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetInstanceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetInstanceAttributeRequest), arg0) 19147 } 19148 19149 // ResetNetworkInterfaceAttribute mocks base method 19150 func (m *MockEC2API) ResetNetworkInterfaceAttribute(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*ec2.ResetNetworkInterfaceAttributeOutput, error) { 19151 m.ctrl.T.Helper() 19152 ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttribute", arg0) 19153 ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput) 19154 ret1, _ := ret[1].(error) 19155 return ret0, ret1 19156 } 19157 19158 // ResetNetworkInterfaceAttribute indicates an expected call of ResetNetworkInterfaceAttribute 19159 func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttribute(arg0 interface{}) *gomock.Call { 19160 mr.mock.ctrl.T.Helper() 19161 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttribute), arg0) 19162 } 19163 19164 // ResetNetworkInterfaceAttributeWithContext mocks base method 19165 func (m *MockEC2API) ResetNetworkInterfaceAttributeWithContext(arg0 aws.Context, arg1 *ec2.ResetNetworkInterfaceAttributeInput, arg2 ...request.Option) (*ec2.ResetNetworkInterfaceAttributeOutput, error) { 19166 m.ctrl.T.Helper() 19167 varargs := []interface{}{arg0, arg1} 19168 for _, a := range arg2 { 19169 varargs = append(varargs, a) 19170 } 19171 ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeWithContext", varargs...) 19172 ret0, _ := ret[0].(*ec2.ResetNetworkInterfaceAttributeOutput) 19173 ret1, _ := ret[1].(error) 19174 return ret0, ret1 19175 } 19176 19177 // ResetNetworkInterfaceAttributeWithContext indicates an expected call of ResetNetworkInterfaceAttributeWithContext 19178 func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19179 mr.mock.ctrl.T.Helper() 19180 varargs := append([]interface{}{arg0, arg1}, arg2...) 19181 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttributeWithContext), varargs...) 19182 } 19183 19184 // ResetNetworkInterfaceAttributeRequest mocks base method 19185 func (m *MockEC2API) ResetNetworkInterfaceAttributeRequest(arg0 *ec2.ResetNetworkInterfaceAttributeInput) (*request.Request, *ec2.ResetNetworkInterfaceAttributeOutput) { 19186 m.ctrl.T.Helper() 19187 ret := m.ctrl.Call(m, "ResetNetworkInterfaceAttributeRequest", arg0) 19188 ret0, _ := ret[0].(*request.Request) 19189 ret1, _ := ret[1].(*ec2.ResetNetworkInterfaceAttributeOutput) 19190 return ret0, ret1 19191 } 19192 19193 // ResetNetworkInterfaceAttributeRequest indicates an expected call of ResetNetworkInterfaceAttributeRequest 19194 func (mr *MockEC2APIMockRecorder) ResetNetworkInterfaceAttributeRequest(arg0 interface{}) *gomock.Call { 19195 mr.mock.ctrl.T.Helper() 19196 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetNetworkInterfaceAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetNetworkInterfaceAttributeRequest), arg0) 19197 } 19198 19199 // ResetSnapshotAttribute mocks base method 19200 func (m *MockEC2API) ResetSnapshotAttribute(arg0 *ec2.ResetSnapshotAttributeInput) (*ec2.ResetSnapshotAttributeOutput, error) { 19201 m.ctrl.T.Helper() 19202 ret := m.ctrl.Call(m, "ResetSnapshotAttribute", arg0) 19203 ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput) 19204 ret1, _ := ret[1].(error) 19205 return ret0, ret1 19206 } 19207 19208 // ResetSnapshotAttribute indicates an expected call of ResetSnapshotAttribute 19209 func (mr *MockEC2APIMockRecorder) ResetSnapshotAttribute(arg0 interface{}) *gomock.Call { 19210 mr.mock.ctrl.T.Helper() 19211 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttribute", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttribute), arg0) 19212 } 19213 19214 // ResetSnapshotAttributeWithContext mocks base method 19215 func (m *MockEC2API) ResetSnapshotAttributeWithContext(arg0 aws.Context, arg1 *ec2.ResetSnapshotAttributeInput, arg2 ...request.Option) (*ec2.ResetSnapshotAttributeOutput, error) { 19216 m.ctrl.T.Helper() 19217 varargs := []interface{}{arg0, arg1} 19218 for _, a := range arg2 { 19219 varargs = append(varargs, a) 19220 } 19221 ret := m.ctrl.Call(m, "ResetSnapshotAttributeWithContext", varargs...) 19222 ret0, _ := ret[0].(*ec2.ResetSnapshotAttributeOutput) 19223 ret1, _ := ret[1].(error) 19224 return ret0, ret1 19225 } 19226 19227 // ResetSnapshotAttributeWithContext indicates an expected call of ResetSnapshotAttributeWithContext 19228 func (mr *MockEC2APIMockRecorder) ResetSnapshotAttributeWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19229 mr.mock.ctrl.T.Helper() 19230 varargs := append([]interface{}{arg0, arg1}, arg2...) 19231 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttributeWithContext", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttributeWithContext), varargs...) 19232 } 19233 19234 // ResetSnapshotAttributeRequest mocks base method 19235 func (m *MockEC2API) ResetSnapshotAttributeRequest(arg0 *ec2.ResetSnapshotAttributeInput) (*request.Request, *ec2.ResetSnapshotAttributeOutput) { 19236 m.ctrl.T.Helper() 19237 ret := m.ctrl.Call(m, "ResetSnapshotAttributeRequest", arg0) 19238 ret0, _ := ret[0].(*request.Request) 19239 ret1, _ := ret[1].(*ec2.ResetSnapshotAttributeOutput) 19240 return ret0, ret1 19241 } 19242 19243 // ResetSnapshotAttributeRequest indicates an expected call of ResetSnapshotAttributeRequest 19244 func (mr *MockEC2APIMockRecorder) ResetSnapshotAttributeRequest(arg0 interface{}) *gomock.Call { 19245 mr.mock.ctrl.T.Helper() 19246 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetSnapshotAttributeRequest", reflect.TypeOf((*MockEC2API)(nil).ResetSnapshotAttributeRequest), arg0) 19247 } 19248 19249 // RestoreAddressToClassic mocks base method 19250 func (m *MockEC2API) RestoreAddressToClassic(arg0 *ec2.RestoreAddressToClassicInput) (*ec2.RestoreAddressToClassicOutput, error) { 19251 m.ctrl.T.Helper() 19252 ret := m.ctrl.Call(m, "RestoreAddressToClassic", arg0) 19253 ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput) 19254 ret1, _ := ret[1].(error) 19255 return ret0, ret1 19256 } 19257 19258 // RestoreAddressToClassic indicates an expected call of RestoreAddressToClassic 19259 func (mr *MockEC2APIMockRecorder) RestoreAddressToClassic(arg0 interface{}) *gomock.Call { 19260 mr.mock.ctrl.T.Helper() 19261 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassic", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassic), arg0) 19262 } 19263 19264 // RestoreAddressToClassicWithContext mocks base method 19265 func (m *MockEC2API) RestoreAddressToClassicWithContext(arg0 aws.Context, arg1 *ec2.RestoreAddressToClassicInput, arg2 ...request.Option) (*ec2.RestoreAddressToClassicOutput, error) { 19266 m.ctrl.T.Helper() 19267 varargs := []interface{}{arg0, arg1} 19268 for _, a := range arg2 { 19269 varargs = append(varargs, a) 19270 } 19271 ret := m.ctrl.Call(m, "RestoreAddressToClassicWithContext", varargs...) 19272 ret0, _ := ret[0].(*ec2.RestoreAddressToClassicOutput) 19273 ret1, _ := ret[1].(error) 19274 return ret0, ret1 19275 } 19276 19277 // RestoreAddressToClassicWithContext indicates an expected call of RestoreAddressToClassicWithContext 19278 func (mr *MockEC2APIMockRecorder) RestoreAddressToClassicWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19279 mr.mock.ctrl.T.Helper() 19280 varargs := append([]interface{}{arg0, arg1}, arg2...) 19281 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassicWithContext", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassicWithContext), varargs...) 19282 } 19283 19284 // RestoreAddressToClassicRequest mocks base method 19285 func (m *MockEC2API) RestoreAddressToClassicRequest(arg0 *ec2.RestoreAddressToClassicInput) (*request.Request, *ec2.RestoreAddressToClassicOutput) { 19286 m.ctrl.T.Helper() 19287 ret := m.ctrl.Call(m, "RestoreAddressToClassicRequest", arg0) 19288 ret0, _ := ret[0].(*request.Request) 19289 ret1, _ := ret[1].(*ec2.RestoreAddressToClassicOutput) 19290 return ret0, ret1 19291 } 19292 19293 // RestoreAddressToClassicRequest indicates an expected call of RestoreAddressToClassicRequest 19294 func (mr *MockEC2APIMockRecorder) RestoreAddressToClassicRequest(arg0 interface{}) *gomock.Call { 19295 mr.mock.ctrl.T.Helper() 19296 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestoreAddressToClassicRequest", reflect.TypeOf((*MockEC2API)(nil).RestoreAddressToClassicRequest), arg0) 19297 } 19298 19299 // RevokeClientVpnIngress mocks base method 19300 func (m *MockEC2API) RevokeClientVpnIngress(arg0 *ec2.RevokeClientVpnIngressInput) (*ec2.RevokeClientVpnIngressOutput, error) { 19301 m.ctrl.T.Helper() 19302 ret := m.ctrl.Call(m, "RevokeClientVpnIngress", arg0) 19303 ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput) 19304 ret1, _ := ret[1].(error) 19305 return ret0, ret1 19306 } 19307 19308 // RevokeClientVpnIngress indicates an expected call of RevokeClientVpnIngress 19309 func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngress(arg0 interface{}) *gomock.Call { 19310 mr.mock.ctrl.T.Helper() 19311 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngress), arg0) 19312 } 19313 19314 // RevokeClientVpnIngressWithContext mocks base method 19315 func (m *MockEC2API) RevokeClientVpnIngressWithContext(arg0 aws.Context, arg1 *ec2.RevokeClientVpnIngressInput, arg2 ...request.Option) (*ec2.RevokeClientVpnIngressOutput, error) { 19316 m.ctrl.T.Helper() 19317 varargs := []interface{}{arg0, arg1} 19318 for _, a := range arg2 { 19319 varargs = append(varargs, a) 19320 } 19321 ret := m.ctrl.Call(m, "RevokeClientVpnIngressWithContext", varargs...) 19322 ret0, _ := ret[0].(*ec2.RevokeClientVpnIngressOutput) 19323 ret1, _ := ret[1].(error) 19324 return ret0, ret1 19325 } 19326 19327 // RevokeClientVpnIngressWithContext indicates an expected call of RevokeClientVpnIngressWithContext 19328 func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19329 mr.mock.ctrl.T.Helper() 19330 varargs := append([]interface{}{arg0, arg1}, arg2...) 19331 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngressWithContext), varargs...) 19332 } 19333 19334 // RevokeClientVpnIngressRequest mocks base method 19335 func (m *MockEC2API) RevokeClientVpnIngressRequest(arg0 *ec2.RevokeClientVpnIngressInput) (*request.Request, *ec2.RevokeClientVpnIngressOutput) { 19336 m.ctrl.T.Helper() 19337 ret := m.ctrl.Call(m, "RevokeClientVpnIngressRequest", arg0) 19338 ret0, _ := ret[0].(*request.Request) 19339 ret1, _ := ret[1].(*ec2.RevokeClientVpnIngressOutput) 19340 return ret0, ret1 19341 } 19342 19343 // RevokeClientVpnIngressRequest indicates an expected call of RevokeClientVpnIngressRequest 19344 func (mr *MockEC2APIMockRecorder) RevokeClientVpnIngressRequest(arg0 interface{}) *gomock.Call { 19345 mr.mock.ctrl.T.Helper() 19346 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeClientVpnIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeClientVpnIngressRequest), arg0) 19347 } 19348 19349 // RevokeSecurityGroupEgress mocks base method 19350 func (m *MockEC2API) RevokeSecurityGroupEgress(arg0 *ec2.RevokeSecurityGroupEgressInput) (*ec2.RevokeSecurityGroupEgressOutput, error) { 19351 m.ctrl.T.Helper() 19352 ret := m.ctrl.Call(m, "RevokeSecurityGroupEgress", arg0) 19353 ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput) 19354 ret1, _ := ret[1].(error) 19355 return ret0, ret1 19356 } 19357 19358 // RevokeSecurityGroupEgress indicates an expected call of RevokeSecurityGroupEgress 19359 func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgress(arg0 interface{}) *gomock.Call { 19360 mr.mock.ctrl.T.Helper() 19361 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgress), arg0) 19362 } 19363 19364 // RevokeSecurityGroupEgressWithContext mocks base method 19365 func (m *MockEC2API) RevokeSecurityGroupEgressWithContext(arg0 aws.Context, arg1 *ec2.RevokeSecurityGroupEgressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupEgressOutput, error) { 19366 m.ctrl.T.Helper() 19367 varargs := []interface{}{arg0, arg1} 19368 for _, a := range arg2 { 19369 varargs = append(varargs, a) 19370 } 19371 ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressWithContext", varargs...) 19372 ret0, _ := ret[0].(*ec2.RevokeSecurityGroupEgressOutput) 19373 ret1, _ := ret[1].(error) 19374 return ret0, ret1 19375 } 19376 19377 // RevokeSecurityGroupEgressWithContext indicates an expected call of RevokeSecurityGroupEgressWithContext 19378 func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19379 mr.mock.ctrl.T.Helper() 19380 varargs := append([]interface{}{arg0, arg1}, arg2...) 19381 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgressWithContext), varargs...) 19382 } 19383 19384 // RevokeSecurityGroupEgressRequest mocks base method 19385 func (m *MockEC2API) RevokeSecurityGroupEgressRequest(arg0 *ec2.RevokeSecurityGroupEgressInput) (*request.Request, *ec2.RevokeSecurityGroupEgressOutput) { 19386 m.ctrl.T.Helper() 19387 ret := m.ctrl.Call(m, "RevokeSecurityGroupEgressRequest", arg0) 19388 ret0, _ := ret[0].(*request.Request) 19389 ret1, _ := ret[1].(*ec2.RevokeSecurityGroupEgressOutput) 19390 return ret0, ret1 19391 } 19392 19393 // RevokeSecurityGroupEgressRequest indicates an expected call of RevokeSecurityGroupEgressRequest 19394 func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupEgressRequest(arg0 interface{}) *gomock.Call { 19395 mr.mock.ctrl.T.Helper() 19396 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupEgressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupEgressRequest), arg0) 19397 } 19398 19399 // RevokeSecurityGroupIngress mocks base method 19400 func (m *MockEC2API) RevokeSecurityGroupIngress(arg0 *ec2.RevokeSecurityGroupIngressInput) (*ec2.RevokeSecurityGroupIngressOutput, error) { 19401 m.ctrl.T.Helper() 19402 ret := m.ctrl.Call(m, "RevokeSecurityGroupIngress", arg0) 19403 ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput) 19404 ret1, _ := ret[1].(error) 19405 return ret0, ret1 19406 } 19407 19408 // RevokeSecurityGroupIngress indicates an expected call of RevokeSecurityGroupIngress 19409 func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngress(arg0 interface{}) *gomock.Call { 19410 mr.mock.ctrl.T.Helper() 19411 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngress", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngress), arg0) 19412 } 19413 19414 // RevokeSecurityGroupIngressWithContext mocks base method 19415 func (m *MockEC2API) RevokeSecurityGroupIngressWithContext(arg0 aws.Context, arg1 *ec2.RevokeSecurityGroupIngressInput, arg2 ...request.Option) (*ec2.RevokeSecurityGroupIngressOutput, error) { 19416 m.ctrl.T.Helper() 19417 varargs := []interface{}{arg0, arg1} 19418 for _, a := range arg2 { 19419 varargs = append(varargs, a) 19420 } 19421 ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressWithContext", varargs...) 19422 ret0, _ := ret[0].(*ec2.RevokeSecurityGroupIngressOutput) 19423 ret1, _ := ret[1].(error) 19424 return ret0, ret1 19425 } 19426 19427 // RevokeSecurityGroupIngressWithContext indicates an expected call of RevokeSecurityGroupIngressWithContext 19428 func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19429 mr.mock.ctrl.T.Helper() 19430 varargs := append([]interface{}{arg0, arg1}, arg2...) 19431 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngressWithContext), varargs...) 19432 } 19433 19434 // RevokeSecurityGroupIngressRequest mocks base method 19435 func (m *MockEC2API) RevokeSecurityGroupIngressRequest(arg0 *ec2.RevokeSecurityGroupIngressInput) (*request.Request, *ec2.RevokeSecurityGroupIngressOutput) { 19436 m.ctrl.T.Helper() 19437 ret := m.ctrl.Call(m, "RevokeSecurityGroupIngressRequest", arg0) 19438 ret0, _ := ret[0].(*request.Request) 19439 ret1, _ := ret[1].(*ec2.RevokeSecurityGroupIngressOutput) 19440 return ret0, ret1 19441 } 19442 19443 // RevokeSecurityGroupIngressRequest indicates an expected call of RevokeSecurityGroupIngressRequest 19444 func (mr *MockEC2APIMockRecorder) RevokeSecurityGroupIngressRequest(arg0 interface{}) *gomock.Call { 19445 mr.mock.ctrl.T.Helper() 19446 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeSecurityGroupIngressRequest", reflect.TypeOf((*MockEC2API)(nil).RevokeSecurityGroupIngressRequest), arg0) 19447 } 19448 19449 // RunInstances mocks base method 19450 func (m *MockEC2API) RunInstances(arg0 *ec2.RunInstancesInput) (*ec2.Reservation, error) { 19451 m.ctrl.T.Helper() 19452 ret := m.ctrl.Call(m, "RunInstances", arg0) 19453 ret0, _ := ret[0].(*ec2.Reservation) 19454 ret1, _ := ret[1].(error) 19455 return ret0, ret1 19456 } 19457 19458 // RunInstances indicates an expected call of RunInstances 19459 func (mr *MockEC2APIMockRecorder) RunInstances(arg0 interface{}) *gomock.Call { 19460 mr.mock.ctrl.T.Helper() 19461 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstances", reflect.TypeOf((*MockEC2API)(nil).RunInstances), arg0) 19462 } 19463 19464 // RunInstancesWithContext mocks base method 19465 func (m *MockEC2API) RunInstancesWithContext(arg0 aws.Context, arg1 *ec2.RunInstancesInput, arg2 ...request.Option) (*ec2.Reservation, error) { 19466 m.ctrl.T.Helper() 19467 varargs := []interface{}{arg0, arg1} 19468 for _, a := range arg2 { 19469 varargs = append(varargs, a) 19470 } 19471 ret := m.ctrl.Call(m, "RunInstancesWithContext", varargs...) 19472 ret0, _ := ret[0].(*ec2.Reservation) 19473 ret1, _ := ret[1].(error) 19474 return ret0, ret1 19475 } 19476 19477 // RunInstancesWithContext indicates an expected call of RunInstancesWithContext 19478 func (mr *MockEC2APIMockRecorder) RunInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19479 mr.mock.ctrl.T.Helper() 19480 varargs := append([]interface{}{arg0, arg1}, arg2...) 19481 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RunInstancesWithContext), varargs...) 19482 } 19483 19484 // RunInstancesRequest mocks base method 19485 func (m *MockEC2API) RunInstancesRequest(arg0 *ec2.RunInstancesInput) (*request.Request, *ec2.Reservation) { 19486 m.ctrl.T.Helper() 19487 ret := m.ctrl.Call(m, "RunInstancesRequest", arg0) 19488 ret0, _ := ret[0].(*request.Request) 19489 ret1, _ := ret[1].(*ec2.Reservation) 19490 return ret0, ret1 19491 } 19492 19493 // RunInstancesRequest indicates an expected call of RunInstancesRequest 19494 func (mr *MockEC2APIMockRecorder) RunInstancesRequest(arg0 interface{}) *gomock.Call { 19495 mr.mock.ctrl.T.Helper() 19496 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunInstancesRequest), arg0) 19497 } 19498 19499 // RunScheduledInstances mocks base method 19500 func (m *MockEC2API) RunScheduledInstances(arg0 *ec2.RunScheduledInstancesInput) (*ec2.RunScheduledInstancesOutput, error) { 19501 m.ctrl.T.Helper() 19502 ret := m.ctrl.Call(m, "RunScheduledInstances", arg0) 19503 ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput) 19504 ret1, _ := ret[1].(error) 19505 return ret0, ret1 19506 } 19507 19508 // RunScheduledInstances indicates an expected call of RunScheduledInstances 19509 func (mr *MockEC2APIMockRecorder) RunScheduledInstances(arg0 interface{}) *gomock.Call { 19510 mr.mock.ctrl.T.Helper() 19511 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstances", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstances), arg0) 19512 } 19513 19514 // RunScheduledInstancesWithContext mocks base method 19515 func (m *MockEC2API) RunScheduledInstancesWithContext(arg0 aws.Context, arg1 *ec2.RunScheduledInstancesInput, arg2 ...request.Option) (*ec2.RunScheduledInstancesOutput, error) { 19516 m.ctrl.T.Helper() 19517 varargs := []interface{}{arg0, arg1} 19518 for _, a := range arg2 { 19519 varargs = append(varargs, a) 19520 } 19521 ret := m.ctrl.Call(m, "RunScheduledInstancesWithContext", varargs...) 19522 ret0, _ := ret[0].(*ec2.RunScheduledInstancesOutput) 19523 ret1, _ := ret[1].(error) 19524 return ret0, ret1 19525 } 19526 19527 // RunScheduledInstancesWithContext indicates an expected call of RunScheduledInstancesWithContext 19528 func (mr *MockEC2APIMockRecorder) RunScheduledInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19529 mr.mock.ctrl.T.Helper() 19530 varargs := append([]interface{}{arg0, arg1}, arg2...) 19531 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstancesWithContext), varargs...) 19532 } 19533 19534 // RunScheduledInstancesRequest mocks base method 19535 func (m *MockEC2API) RunScheduledInstancesRequest(arg0 *ec2.RunScheduledInstancesInput) (*request.Request, *ec2.RunScheduledInstancesOutput) { 19536 m.ctrl.T.Helper() 19537 ret := m.ctrl.Call(m, "RunScheduledInstancesRequest", arg0) 19538 ret0, _ := ret[0].(*request.Request) 19539 ret1, _ := ret[1].(*ec2.RunScheduledInstancesOutput) 19540 return ret0, ret1 19541 } 19542 19543 // RunScheduledInstancesRequest indicates an expected call of RunScheduledInstancesRequest 19544 func (mr *MockEC2APIMockRecorder) RunScheduledInstancesRequest(arg0 interface{}) *gomock.Call { 19545 mr.mock.ctrl.T.Helper() 19546 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunScheduledInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).RunScheduledInstancesRequest), arg0) 19547 } 19548 19549 // SearchTransitGatewayRoutes mocks base method 19550 func (m *MockEC2API) SearchTransitGatewayRoutes(arg0 *ec2.SearchTransitGatewayRoutesInput) (*ec2.SearchTransitGatewayRoutesOutput, error) { 19551 m.ctrl.T.Helper() 19552 ret := m.ctrl.Call(m, "SearchTransitGatewayRoutes", arg0) 19553 ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput) 19554 ret1, _ := ret[1].(error) 19555 return ret0, ret1 19556 } 19557 19558 // SearchTransitGatewayRoutes indicates an expected call of SearchTransitGatewayRoutes 19559 func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutes(arg0 interface{}) *gomock.Call { 19560 mr.mock.ctrl.T.Helper() 19561 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutes", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutes), arg0) 19562 } 19563 19564 // SearchTransitGatewayRoutesWithContext mocks base method 19565 func (m *MockEC2API) SearchTransitGatewayRoutesWithContext(arg0 aws.Context, arg1 *ec2.SearchTransitGatewayRoutesInput, arg2 ...request.Option) (*ec2.SearchTransitGatewayRoutesOutput, error) { 19566 m.ctrl.T.Helper() 19567 varargs := []interface{}{arg0, arg1} 19568 for _, a := range arg2 { 19569 varargs = append(varargs, a) 19570 } 19571 ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesWithContext", varargs...) 19572 ret0, _ := ret[0].(*ec2.SearchTransitGatewayRoutesOutput) 19573 ret1, _ := ret[1].(error) 19574 return ret0, ret1 19575 } 19576 19577 // SearchTransitGatewayRoutesWithContext indicates an expected call of SearchTransitGatewayRoutesWithContext 19578 func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19579 mr.mock.ctrl.T.Helper() 19580 varargs := append([]interface{}{arg0, arg1}, arg2...) 19581 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutesWithContext", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutesWithContext), varargs...) 19582 } 19583 19584 // SearchTransitGatewayRoutesRequest mocks base method 19585 func (m *MockEC2API) SearchTransitGatewayRoutesRequest(arg0 *ec2.SearchTransitGatewayRoutesInput) (*request.Request, *ec2.SearchTransitGatewayRoutesOutput) { 19586 m.ctrl.T.Helper() 19587 ret := m.ctrl.Call(m, "SearchTransitGatewayRoutesRequest", arg0) 19588 ret0, _ := ret[0].(*request.Request) 19589 ret1, _ := ret[1].(*ec2.SearchTransitGatewayRoutesOutput) 19590 return ret0, ret1 19591 } 19592 19593 // SearchTransitGatewayRoutesRequest indicates an expected call of SearchTransitGatewayRoutesRequest 19594 func (mr *MockEC2APIMockRecorder) SearchTransitGatewayRoutesRequest(arg0 interface{}) *gomock.Call { 19595 mr.mock.ctrl.T.Helper() 19596 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SearchTransitGatewayRoutesRequest", reflect.TypeOf((*MockEC2API)(nil).SearchTransitGatewayRoutesRequest), arg0) 19597 } 19598 19599 // SendDiagnosticInterrupt mocks base method 19600 func (m *MockEC2API) SendDiagnosticInterrupt(arg0 *ec2.SendDiagnosticInterruptInput) (*ec2.SendDiagnosticInterruptOutput, error) { 19601 m.ctrl.T.Helper() 19602 ret := m.ctrl.Call(m, "SendDiagnosticInterrupt", arg0) 19603 ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput) 19604 ret1, _ := ret[1].(error) 19605 return ret0, ret1 19606 } 19607 19608 // SendDiagnosticInterrupt indicates an expected call of SendDiagnosticInterrupt 19609 func (mr *MockEC2APIMockRecorder) SendDiagnosticInterrupt(arg0 interface{}) *gomock.Call { 19610 mr.mock.ctrl.T.Helper() 19611 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterrupt", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterrupt), arg0) 19612 } 19613 19614 // SendDiagnosticInterruptWithContext mocks base method 19615 func (m *MockEC2API) SendDiagnosticInterruptWithContext(arg0 aws.Context, arg1 *ec2.SendDiagnosticInterruptInput, arg2 ...request.Option) (*ec2.SendDiagnosticInterruptOutput, error) { 19616 m.ctrl.T.Helper() 19617 varargs := []interface{}{arg0, arg1} 19618 for _, a := range arg2 { 19619 varargs = append(varargs, a) 19620 } 19621 ret := m.ctrl.Call(m, "SendDiagnosticInterruptWithContext", varargs...) 19622 ret0, _ := ret[0].(*ec2.SendDiagnosticInterruptOutput) 19623 ret1, _ := ret[1].(error) 19624 return ret0, ret1 19625 } 19626 19627 // SendDiagnosticInterruptWithContext indicates an expected call of SendDiagnosticInterruptWithContext 19628 func (mr *MockEC2APIMockRecorder) SendDiagnosticInterruptWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19629 mr.mock.ctrl.T.Helper() 19630 varargs := append([]interface{}{arg0, arg1}, arg2...) 19631 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterruptWithContext", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterruptWithContext), varargs...) 19632 } 19633 19634 // SendDiagnosticInterruptRequest mocks base method 19635 func (m *MockEC2API) SendDiagnosticInterruptRequest(arg0 *ec2.SendDiagnosticInterruptInput) (*request.Request, *ec2.SendDiagnosticInterruptOutput) { 19636 m.ctrl.T.Helper() 19637 ret := m.ctrl.Call(m, "SendDiagnosticInterruptRequest", arg0) 19638 ret0, _ := ret[0].(*request.Request) 19639 ret1, _ := ret[1].(*ec2.SendDiagnosticInterruptOutput) 19640 return ret0, ret1 19641 } 19642 19643 // SendDiagnosticInterruptRequest indicates an expected call of SendDiagnosticInterruptRequest 19644 func (mr *MockEC2APIMockRecorder) SendDiagnosticInterruptRequest(arg0 interface{}) *gomock.Call { 19645 mr.mock.ctrl.T.Helper() 19646 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SendDiagnosticInterruptRequest", reflect.TypeOf((*MockEC2API)(nil).SendDiagnosticInterruptRequest), arg0) 19647 } 19648 19649 // StartInstances mocks base method 19650 func (m *MockEC2API) StartInstances(arg0 *ec2.StartInstancesInput) (*ec2.StartInstancesOutput, error) { 19651 m.ctrl.T.Helper() 19652 ret := m.ctrl.Call(m, "StartInstances", arg0) 19653 ret0, _ := ret[0].(*ec2.StartInstancesOutput) 19654 ret1, _ := ret[1].(error) 19655 return ret0, ret1 19656 } 19657 19658 // StartInstances indicates an expected call of StartInstances 19659 func (mr *MockEC2APIMockRecorder) StartInstances(arg0 interface{}) *gomock.Call { 19660 mr.mock.ctrl.T.Helper() 19661 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstances", reflect.TypeOf((*MockEC2API)(nil).StartInstances), arg0) 19662 } 19663 19664 // StartInstancesWithContext mocks base method 19665 func (m *MockEC2API) StartInstancesWithContext(arg0 aws.Context, arg1 *ec2.StartInstancesInput, arg2 ...request.Option) (*ec2.StartInstancesOutput, error) { 19666 m.ctrl.T.Helper() 19667 varargs := []interface{}{arg0, arg1} 19668 for _, a := range arg2 { 19669 varargs = append(varargs, a) 19670 } 19671 ret := m.ctrl.Call(m, "StartInstancesWithContext", varargs...) 19672 ret0, _ := ret[0].(*ec2.StartInstancesOutput) 19673 ret1, _ := ret[1].(error) 19674 return ret0, ret1 19675 } 19676 19677 // StartInstancesWithContext indicates an expected call of StartInstancesWithContext 19678 func (mr *MockEC2APIMockRecorder) StartInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19679 mr.mock.ctrl.T.Helper() 19680 varargs := append([]interface{}{arg0, arg1}, arg2...) 19681 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).StartInstancesWithContext), varargs...) 19682 } 19683 19684 // StartInstancesRequest mocks base method 19685 func (m *MockEC2API) StartInstancesRequest(arg0 *ec2.StartInstancesInput) (*request.Request, *ec2.StartInstancesOutput) { 19686 m.ctrl.T.Helper() 19687 ret := m.ctrl.Call(m, "StartInstancesRequest", arg0) 19688 ret0, _ := ret[0].(*request.Request) 19689 ret1, _ := ret[1].(*ec2.StartInstancesOutput) 19690 return ret0, ret1 19691 } 19692 19693 // StartInstancesRequest indicates an expected call of StartInstancesRequest 19694 func (mr *MockEC2APIMockRecorder) StartInstancesRequest(arg0 interface{}) *gomock.Call { 19695 mr.mock.ctrl.T.Helper() 19696 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StartInstancesRequest), arg0) 19697 } 19698 19699 // StopInstances mocks base method 19700 func (m *MockEC2API) StopInstances(arg0 *ec2.StopInstancesInput) (*ec2.StopInstancesOutput, error) { 19701 m.ctrl.T.Helper() 19702 ret := m.ctrl.Call(m, "StopInstances", arg0) 19703 ret0, _ := ret[0].(*ec2.StopInstancesOutput) 19704 ret1, _ := ret[1].(error) 19705 return ret0, ret1 19706 } 19707 19708 // StopInstances indicates an expected call of StopInstances 19709 func (mr *MockEC2APIMockRecorder) StopInstances(arg0 interface{}) *gomock.Call { 19710 mr.mock.ctrl.T.Helper() 19711 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstances", reflect.TypeOf((*MockEC2API)(nil).StopInstances), arg0) 19712 } 19713 19714 // StopInstancesWithContext mocks base method 19715 func (m *MockEC2API) StopInstancesWithContext(arg0 aws.Context, arg1 *ec2.StopInstancesInput, arg2 ...request.Option) (*ec2.StopInstancesOutput, error) { 19716 m.ctrl.T.Helper() 19717 varargs := []interface{}{arg0, arg1} 19718 for _, a := range arg2 { 19719 varargs = append(varargs, a) 19720 } 19721 ret := m.ctrl.Call(m, "StopInstancesWithContext", varargs...) 19722 ret0, _ := ret[0].(*ec2.StopInstancesOutput) 19723 ret1, _ := ret[1].(error) 19724 return ret0, ret1 19725 } 19726 19727 // StopInstancesWithContext indicates an expected call of StopInstancesWithContext 19728 func (mr *MockEC2APIMockRecorder) StopInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19729 mr.mock.ctrl.T.Helper() 19730 varargs := append([]interface{}{arg0, arg1}, arg2...) 19731 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).StopInstancesWithContext), varargs...) 19732 } 19733 19734 // StopInstancesRequest mocks base method 19735 func (m *MockEC2API) StopInstancesRequest(arg0 *ec2.StopInstancesInput) (*request.Request, *ec2.StopInstancesOutput) { 19736 m.ctrl.T.Helper() 19737 ret := m.ctrl.Call(m, "StopInstancesRequest", arg0) 19738 ret0, _ := ret[0].(*request.Request) 19739 ret1, _ := ret[1].(*ec2.StopInstancesOutput) 19740 return ret0, ret1 19741 } 19742 19743 // StopInstancesRequest indicates an expected call of StopInstancesRequest 19744 func (mr *MockEC2APIMockRecorder) StopInstancesRequest(arg0 interface{}) *gomock.Call { 19745 mr.mock.ctrl.T.Helper() 19746 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).StopInstancesRequest), arg0) 19747 } 19748 19749 // TerminateClientVpnConnections mocks base method 19750 func (m *MockEC2API) TerminateClientVpnConnections(arg0 *ec2.TerminateClientVpnConnectionsInput) (*ec2.TerminateClientVpnConnectionsOutput, error) { 19751 m.ctrl.T.Helper() 19752 ret := m.ctrl.Call(m, "TerminateClientVpnConnections", arg0) 19753 ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput) 19754 ret1, _ := ret[1].(error) 19755 return ret0, ret1 19756 } 19757 19758 // TerminateClientVpnConnections indicates an expected call of TerminateClientVpnConnections 19759 func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnections(arg0 interface{}) *gomock.Call { 19760 mr.mock.ctrl.T.Helper() 19761 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnections", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnections), arg0) 19762 } 19763 19764 // TerminateClientVpnConnectionsWithContext mocks base method 19765 func (m *MockEC2API) TerminateClientVpnConnectionsWithContext(arg0 aws.Context, arg1 *ec2.TerminateClientVpnConnectionsInput, arg2 ...request.Option) (*ec2.TerminateClientVpnConnectionsOutput, error) { 19766 m.ctrl.T.Helper() 19767 varargs := []interface{}{arg0, arg1} 19768 for _, a := range arg2 { 19769 varargs = append(varargs, a) 19770 } 19771 ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsWithContext", varargs...) 19772 ret0, _ := ret[0].(*ec2.TerminateClientVpnConnectionsOutput) 19773 ret1, _ := ret[1].(error) 19774 return ret0, ret1 19775 } 19776 19777 // TerminateClientVpnConnectionsWithContext indicates an expected call of TerminateClientVpnConnectionsWithContext 19778 func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnectionsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19779 mr.mock.ctrl.T.Helper() 19780 varargs := append([]interface{}{arg0, arg1}, arg2...) 19781 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnectionsWithContext", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnectionsWithContext), varargs...) 19782 } 19783 19784 // TerminateClientVpnConnectionsRequest mocks base method 19785 func (m *MockEC2API) TerminateClientVpnConnectionsRequest(arg0 *ec2.TerminateClientVpnConnectionsInput) (*request.Request, *ec2.TerminateClientVpnConnectionsOutput) { 19786 m.ctrl.T.Helper() 19787 ret := m.ctrl.Call(m, "TerminateClientVpnConnectionsRequest", arg0) 19788 ret0, _ := ret[0].(*request.Request) 19789 ret1, _ := ret[1].(*ec2.TerminateClientVpnConnectionsOutput) 19790 return ret0, ret1 19791 } 19792 19793 // TerminateClientVpnConnectionsRequest indicates an expected call of TerminateClientVpnConnectionsRequest 19794 func (mr *MockEC2APIMockRecorder) TerminateClientVpnConnectionsRequest(arg0 interface{}) *gomock.Call { 19795 mr.mock.ctrl.T.Helper() 19796 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateClientVpnConnectionsRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateClientVpnConnectionsRequest), arg0) 19797 } 19798 19799 // TerminateInstances mocks base method 19800 func (m *MockEC2API) TerminateInstances(arg0 *ec2.TerminateInstancesInput) (*ec2.TerminateInstancesOutput, error) { 19801 m.ctrl.T.Helper() 19802 ret := m.ctrl.Call(m, "TerminateInstances", arg0) 19803 ret0, _ := ret[0].(*ec2.TerminateInstancesOutput) 19804 ret1, _ := ret[1].(error) 19805 return ret0, ret1 19806 } 19807 19808 // TerminateInstances indicates an expected call of TerminateInstances 19809 func (mr *MockEC2APIMockRecorder) TerminateInstances(arg0 interface{}) *gomock.Call { 19810 mr.mock.ctrl.T.Helper() 19811 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstances", reflect.TypeOf((*MockEC2API)(nil).TerminateInstances), arg0) 19812 } 19813 19814 // TerminateInstancesWithContext mocks base method 19815 func (m *MockEC2API) TerminateInstancesWithContext(arg0 aws.Context, arg1 *ec2.TerminateInstancesInput, arg2 ...request.Option) (*ec2.TerminateInstancesOutput, error) { 19816 m.ctrl.T.Helper() 19817 varargs := []interface{}{arg0, arg1} 19818 for _, a := range arg2 { 19819 varargs = append(varargs, a) 19820 } 19821 ret := m.ctrl.Call(m, "TerminateInstancesWithContext", varargs...) 19822 ret0, _ := ret[0].(*ec2.TerminateInstancesOutput) 19823 ret1, _ := ret[1].(error) 19824 return ret0, ret1 19825 } 19826 19827 // TerminateInstancesWithContext indicates an expected call of TerminateInstancesWithContext 19828 func (mr *MockEC2APIMockRecorder) TerminateInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19829 mr.mock.ctrl.T.Helper() 19830 varargs := append([]interface{}{arg0, arg1}, arg2...) 19831 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).TerminateInstancesWithContext), varargs...) 19832 } 19833 19834 // TerminateInstancesRequest mocks base method 19835 func (m *MockEC2API) TerminateInstancesRequest(arg0 *ec2.TerminateInstancesInput) (*request.Request, *ec2.TerminateInstancesOutput) { 19836 m.ctrl.T.Helper() 19837 ret := m.ctrl.Call(m, "TerminateInstancesRequest", arg0) 19838 ret0, _ := ret[0].(*request.Request) 19839 ret1, _ := ret[1].(*ec2.TerminateInstancesOutput) 19840 return ret0, ret1 19841 } 19842 19843 // TerminateInstancesRequest indicates an expected call of TerminateInstancesRequest 19844 func (mr *MockEC2APIMockRecorder) TerminateInstancesRequest(arg0 interface{}) *gomock.Call { 19845 mr.mock.ctrl.T.Helper() 19846 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TerminateInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).TerminateInstancesRequest), arg0) 19847 } 19848 19849 // UnassignIpv6Addresses mocks base method 19850 func (m *MockEC2API) UnassignIpv6Addresses(arg0 *ec2.UnassignIpv6AddressesInput) (*ec2.UnassignIpv6AddressesOutput, error) { 19851 m.ctrl.T.Helper() 19852 ret := m.ctrl.Call(m, "UnassignIpv6Addresses", arg0) 19853 ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput) 19854 ret1, _ := ret[1].(error) 19855 return ret0, ret1 19856 } 19857 19858 // UnassignIpv6Addresses indicates an expected call of UnassignIpv6Addresses 19859 func (mr *MockEC2APIMockRecorder) UnassignIpv6Addresses(arg0 interface{}) *gomock.Call { 19860 mr.mock.ctrl.T.Helper() 19861 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6Addresses", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6Addresses), arg0) 19862 } 19863 19864 // UnassignIpv6AddressesWithContext mocks base method 19865 func (m *MockEC2API) UnassignIpv6AddressesWithContext(arg0 aws.Context, arg1 *ec2.UnassignIpv6AddressesInput, arg2 ...request.Option) (*ec2.UnassignIpv6AddressesOutput, error) { 19866 m.ctrl.T.Helper() 19867 varargs := []interface{}{arg0, arg1} 19868 for _, a := range arg2 { 19869 varargs = append(varargs, a) 19870 } 19871 ret := m.ctrl.Call(m, "UnassignIpv6AddressesWithContext", varargs...) 19872 ret0, _ := ret[0].(*ec2.UnassignIpv6AddressesOutput) 19873 ret1, _ := ret[1].(error) 19874 return ret0, ret1 19875 } 19876 19877 // UnassignIpv6AddressesWithContext indicates an expected call of UnassignIpv6AddressesWithContext 19878 func (mr *MockEC2APIMockRecorder) UnassignIpv6AddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19879 mr.mock.ctrl.T.Helper() 19880 varargs := append([]interface{}{arg0, arg1}, arg2...) 19881 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6AddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6AddressesWithContext), varargs...) 19882 } 19883 19884 // UnassignIpv6AddressesRequest mocks base method 19885 func (m *MockEC2API) UnassignIpv6AddressesRequest(arg0 *ec2.UnassignIpv6AddressesInput) (*request.Request, *ec2.UnassignIpv6AddressesOutput) { 19886 m.ctrl.T.Helper() 19887 ret := m.ctrl.Call(m, "UnassignIpv6AddressesRequest", arg0) 19888 ret0, _ := ret[0].(*request.Request) 19889 ret1, _ := ret[1].(*ec2.UnassignIpv6AddressesOutput) 19890 return ret0, ret1 19891 } 19892 19893 // UnassignIpv6AddressesRequest indicates an expected call of UnassignIpv6AddressesRequest 19894 func (mr *MockEC2APIMockRecorder) UnassignIpv6AddressesRequest(arg0 interface{}) *gomock.Call { 19895 mr.mock.ctrl.T.Helper() 19896 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignIpv6AddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignIpv6AddressesRequest), arg0) 19897 } 19898 19899 // UnassignPrivateIpAddresses mocks base method 19900 func (m *MockEC2API) UnassignPrivateIpAddresses(arg0 *ec2.UnassignPrivateIpAddressesInput) (*ec2.UnassignPrivateIpAddressesOutput, error) { 19901 m.ctrl.T.Helper() 19902 ret := m.ctrl.Call(m, "UnassignPrivateIpAddresses", arg0) 19903 ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput) 19904 ret1, _ := ret[1].(error) 19905 return ret0, ret1 19906 } 19907 19908 // UnassignPrivateIpAddresses indicates an expected call of UnassignPrivateIpAddresses 19909 func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddresses(arg0 interface{}) *gomock.Call { 19910 mr.mock.ctrl.T.Helper() 19911 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddresses", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddresses), arg0) 19912 } 19913 19914 // UnassignPrivateIpAddressesWithContext mocks base method 19915 func (m *MockEC2API) UnassignPrivateIpAddressesWithContext(arg0 aws.Context, arg1 *ec2.UnassignPrivateIpAddressesInput, arg2 ...request.Option) (*ec2.UnassignPrivateIpAddressesOutput, error) { 19916 m.ctrl.T.Helper() 19917 varargs := []interface{}{arg0, arg1} 19918 for _, a := range arg2 { 19919 varargs = append(varargs, a) 19920 } 19921 ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesWithContext", varargs...) 19922 ret0, _ := ret[0].(*ec2.UnassignPrivateIpAddressesOutput) 19923 ret1, _ := ret[1].(error) 19924 return ret0, ret1 19925 } 19926 19927 // UnassignPrivateIpAddressesWithContext indicates an expected call of UnassignPrivateIpAddressesWithContext 19928 func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddressesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19929 mr.mock.ctrl.T.Helper() 19930 varargs := append([]interface{}{arg0, arg1}, arg2...) 19931 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesWithContext), varargs...) 19932 } 19933 19934 // UnassignPrivateIpAddressesRequest mocks base method 19935 func (m *MockEC2API) UnassignPrivateIpAddressesRequest(arg0 *ec2.UnassignPrivateIpAddressesInput) (*request.Request, *ec2.UnassignPrivateIpAddressesOutput) { 19936 m.ctrl.T.Helper() 19937 ret := m.ctrl.Call(m, "UnassignPrivateIpAddressesRequest", arg0) 19938 ret0, _ := ret[0].(*request.Request) 19939 ret1, _ := ret[1].(*ec2.UnassignPrivateIpAddressesOutput) 19940 return ret0, ret1 19941 } 19942 19943 // UnassignPrivateIpAddressesRequest indicates an expected call of UnassignPrivateIpAddressesRequest 19944 func (mr *MockEC2APIMockRecorder) UnassignPrivateIpAddressesRequest(arg0 interface{}) *gomock.Call { 19945 mr.mock.ctrl.T.Helper() 19946 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnassignPrivateIpAddressesRequest", reflect.TypeOf((*MockEC2API)(nil).UnassignPrivateIpAddressesRequest), arg0) 19947 } 19948 19949 // UnmonitorInstances mocks base method 19950 func (m *MockEC2API) UnmonitorInstances(arg0 *ec2.UnmonitorInstancesInput) (*ec2.UnmonitorInstancesOutput, error) { 19951 m.ctrl.T.Helper() 19952 ret := m.ctrl.Call(m, "UnmonitorInstances", arg0) 19953 ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput) 19954 ret1, _ := ret[1].(error) 19955 return ret0, ret1 19956 } 19957 19958 // UnmonitorInstances indicates an expected call of UnmonitorInstances 19959 func (mr *MockEC2APIMockRecorder) UnmonitorInstances(arg0 interface{}) *gomock.Call { 19960 mr.mock.ctrl.T.Helper() 19961 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstances", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstances), arg0) 19962 } 19963 19964 // UnmonitorInstancesWithContext mocks base method 19965 func (m *MockEC2API) UnmonitorInstancesWithContext(arg0 aws.Context, arg1 *ec2.UnmonitorInstancesInput, arg2 ...request.Option) (*ec2.UnmonitorInstancesOutput, error) { 19966 m.ctrl.T.Helper() 19967 varargs := []interface{}{arg0, arg1} 19968 for _, a := range arg2 { 19969 varargs = append(varargs, a) 19970 } 19971 ret := m.ctrl.Call(m, "UnmonitorInstancesWithContext", varargs...) 19972 ret0, _ := ret[0].(*ec2.UnmonitorInstancesOutput) 19973 ret1, _ := ret[1].(error) 19974 return ret0, ret1 19975 } 19976 19977 // UnmonitorInstancesWithContext indicates an expected call of UnmonitorInstancesWithContext 19978 func (mr *MockEC2APIMockRecorder) UnmonitorInstancesWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 19979 mr.mock.ctrl.T.Helper() 19980 varargs := append([]interface{}{arg0, arg1}, arg2...) 19981 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstancesWithContext", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstancesWithContext), varargs...) 19982 } 19983 19984 // UnmonitorInstancesRequest mocks base method 19985 func (m *MockEC2API) UnmonitorInstancesRequest(arg0 *ec2.UnmonitorInstancesInput) (*request.Request, *ec2.UnmonitorInstancesOutput) { 19986 m.ctrl.T.Helper() 19987 ret := m.ctrl.Call(m, "UnmonitorInstancesRequest", arg0) 19988 ret0, _ := ret[0].(*request.Request) 19989 ret1, _ := ret[1].(*ec2.UnmonitorInstancesOutput) 19990 return ret0, ret1 19991 } 19992 19993 // UnmonitorInstancesRequest indicates an expected call of UnmonitorInstancesRequest 19994 func (mr *MockEC2APIMockRecorder) UnmonitorInstancesRequest(arg0 interface{}) *gomock.Call { 19995 mr.mock.ctrl.T.Helper() 19996 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnmonitorInstancesRequest", reflect.TypeOf((*MockEC2API)(nil).UnmonitorInstancesRequest), arg0) 19997 } 19998 19999 // UpdateSecurityGroupRuleDescriptionsEgress mocks base method 20000 func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) { 20001 m.ctrl.T.Helper() 20002 ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgress", arg0) 20003 ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) 20004 ret1, _ := ret[1].(error) 20005 return ret0, ret1 20006 } 20007 20008 // UpdateSecurityGroupRuleDescriptionsEgress indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgress 20009 func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgress(arg0 interface{}) *gomock.Call { 20010 mr.mock.ctrl.T.Helper() 20011 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgress), arg0) 20012 } 20013 20014 // UpdateSecurityGroupRuleDescriptionsEgressWithContext mocks base method 20015 func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressWithContext(arg0 aws.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput, error) { 20016 m.ctrl.T.Helper() 20017 varargs := []interface{}{arg0, arg1} 20018 for _, a := range arg2 { 20019 varargs = append(varargs, a) 20020 } 20021 ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", varargs...) 20022 ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) 20023 ret1, _ := ret[1].(error) 20024 return ret0, ret1 20025 } 20026 20027 // UpdateSecurityGroupRuleDescriptionsEgressWithContext indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressWithContext 20028 func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20029 mr.mock.ctrl.T.Helper() 20030 varargs := append([]interface{}{arg0, arg1}, arg2...) 20031 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgressWithContext", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressWithContext), varargs...) 20032 } 20033 20034 // UpdateSecurityGroupRuleDescriptionsEgressRequest mocks base method 20035 func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsEgressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) { 20036 m.ctrl.T.Helper() 20037 ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsEgressRequest", arg0) 20038 ret0, _ := ret[0].(*request.Request) 20039 ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsEgressOutput) 20040 return ret0, ret1 20041 } 20042 20043 // UpdateSecurityGroupRuleDescriptionsEgressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsEgressRequest 20044 func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsEgressRequest(arg0 interface{}) *gomock.Call { 20045 mr.mock.ctrl.T.Helper() 20046 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsEgressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsEgressRequest), arg0) 20047 } 20048 20049 // UpdateSecurityGroupRuleDescriptionsIngress mocks base method 20050 func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngress(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) { 20051 m.ctrl.T.Helper() 20052 ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngress", arg0) 20053 ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) 20054 ret1, _ := ret[1].(error) 20055 return ret0, ret1 20056 } 20057 20058 // UpdateSecurityGroupRuleDescriptionsIngress indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngress 20059 func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngress(arg0 interface{}) *gomock.Call { 20060 mr.mock.ctrl.T.Helper() 20061 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngress", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngress), arg0) 20062 } 20063 20064 // UpdateSecurityGroupRuleDescriptionsIngressWithContext mocks base method 20065 func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressWithContext(arg0 aws.Context, arg1 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput, arg2 ...request.Option) (*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput, error) { 20066 m.ctrl.T.Helper() 20067 varargs := []interface{}{arg0, arg1} 20068 for _, a := range arg2 { 20069 varargs = append(varargs, a) 20070 } 20071 ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", varargs...) 20072 ret0, _ := ret[0].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) 20073 ret1, _ := ret[1].(error) 20074 return ret0, ret1 20075 } 20076 20077 // UpdateSecurityGroupRuleDescriptionsIngressWithContext indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressWithContext 20078 func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngressWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20079 mr.mock.ctrl.T.Helper() 20080 varargs := append([]interface{}{arg0, arg1}, arg2...) 20081 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngressWithContext", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressWithContext), varargs...) 20082 } 20083 20084 // UpdateSecurityGroupRuleDescriptionsIngressRequest mocks base method 20085 func (m *MockEC2API) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 *ec2.UpdateSecurityGroupRuleDescriptionsIngressInput) (*request.Request, *ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) { 20086 m.ctrl.T.Helper() 20087 ret := m.ctrl.Call(m, "UpdateSecurityGroupRuleDescriptionsIngressRequest", arg0) 20088 ret0, _ := ret[0].(*request.Request) 20089 ret1, _ := ret[1].(*ec2.UpdateSecurityGroupRuleDescriptionsIngressOutput) 20090 return ret0, ret1 20091 } 20092 20093 // UpdateSecurityGroupRuleDescriptionsIngressRequest indicates an expected call of UpdateSecurityGroupRuleDescriptionsIngressRequest 20094 func (mr *MockEC2APIMockRecorder) UpdateSecurityGroupRuleDescriptionsIngressRequest(arg0 interface{}) *gomock.Call { 20095 mr.mock.ctrl.T.Helper() 20096 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSecurityGroupRuleDescriptionsIngressRequest", reflect.TypeOf((*MockEC2API)(nil).UpdateSecurityGroupRuleDescriptionsIngressRequest), arg0) 20097 } 20098 20099 // WithdrawByoipCidr mocks base method 20100 func (m *MockEC2API) WithdrawByoipCidr(arg0 *ec2.WithdrawByoipCidrInput) (*ec2.WithdrawByoipCidrOutput, error) { 20101 m.ctrl.T.Helper() 20102 ret := m.ctrl.Call(m, "WithdrawByoipCidr", arg0) 20103 ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput) 20104 ret1, _ := ret[1].(error) 20105 return ret0, ret1 20106 } 20107 20108 // WithdrawByoipCidr indicates an expected call of WithdrawByoipCidr 20109 func (mr *MockEC2APIMockRecorder) WithdrawByoipCidr(arg0 interface{}) *gomock.Call { 20110 mr.mock.ctrl.T.Helper() 20111 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidr", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidr), arg0) 20112 } 20113 20114 // WithdrawByoipCidrWithContext mocks base method 20115 func (m *MockEC2API) WithdrawByoipCidrWithContext(arg0 aws.Context, arg1 *ec2.WithdrawByoipCidrInput, arg2 ...request.Option) (*ec2.WithdrawByoipCidrOutput, error) { 20116 m.ctrl.T.Helper() 20117 varargs := []interface{}{arg0, arg1} 20118 for _, a := range arg2 { 20119 varargs = append(varargs, a) 20120 } 20121 ret := m.ctrl.Call(m, "WithdrawByoipCidrWithContext", varargs...) 20122 ret0, _ := ret[0].(*ec2.WithdrawByoipCidrOutput) 20123 ret1, _ := ret[1].(error) 20124 return ret0, ret1 20125 } 20126 20127 // WithdrawByoipCidrWithContext indicates an expected call of WithdrawByoipCidrWithContext 20128 func (mr *MockEC2APIMockRecorder) WithdrawByoipCidrWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20129 mr.mock.ctrl.T.Helper() 20130 varargs := append([]interface{}{arg0, arg1}, arg2...) 20131 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrWithContext", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrWithContext), varargs...) 20132 } 20133 20134 // WithdrawByoipCidrRequest mocks base method 20135 func (m *MockEC2API) WithdrawByoipCidrRequest(arg0 *ec2.WithdrawByoipCidrInput) (*request.Request, *ec2.WithdrawByoipCidrOutput) { 20136 m.ctrl.T.Helper() 20137 ret := m.ctrl.Call(m, "WithdrawByoipCidrRequest", arg0) 20138 ret0, _ := ret[0].(*request.Request) 20139 ret1, _ := ret[1].(*ec2.WithdrawByoipCidrOutput) 20140 return ret0, ret1 20141 } 20142 20143 // WithdrawByoipCidrRequest indicates an expected call of WithdrawByoipCidrRequest 20144 func (mr *MockEC2APIMockRecorder) WithdrawByoipCidrRequest(arg0 interface{}) *gomock.Call { 20145 mr.mock.ctrl.T.Helper() 20146 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithdrawByoipCidrRequest", reflect.TypeOf((*MockEC2API)(nil).WithdrawByoipCidrRequest), arg0) 20147 } 20148 20149 // WaitUntilBundleTaskComplete mocks base method 20150 func (m *MockEC2API) WaitUntilBundleTaskComplete(arg0 *ec2.DescribeBundleTasksInput) error { 20151 m.ctrl.T.Helper() 20152 ret := m.ctrl.Call(m, "WaitUntilBundleTaskComplete", arg0) 20153 ret0, _ := ret[0].(error) 20154 return ret0 20155 } 20156 20157 // WaitUntilBundleTaskComplete indicates an expected call of WaitUntilBundleTaskComplete 20158 func (mr *MockEC2APIMockRecorder) WaitUntilBundleTaskComplete(arg0 interface{}) *gomock.Call { 20159 mr.mock.ctrl.T.Helper() 20160 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBundleTaskComplete", reflect.TypeOf((*MockEC2API)(nil).WaitUntilBundleTaskComplete), arg0) 20161 } 20162 20163 // WaitUntilBundleTaskCompleteWithContext mocks base method 20164 func (m *MockEC2API) WaitUntilBundleTaskCompleteWithContext(arg0 aws.Context, arg1 *ec2.DescribeBundleTasksInput, arg2 ...request.WaiterOption) error { 20165 m.ctrl.T.Helper() 20166 varargs := []interface{}{arg0, arg1} 20167 for _, a := range arg2 { 20168 varargs = append(varargs, a) 20169 } 20170 ret := m.ctrl.Call(m, "WaitUntilBundleTaskCompleteWithContext", varargs...) 20171 ret0, _ := ret[0].(error) 20172 return ret0 20173 } 20174 20175 // WaitUntilBundleTaskCompleteWithContext indicates an expected call of WaitUntilBundleTaskCompleteWithContext 20176 func (mr *MockEC2APIMockRecorder) WaitUntilBundleTaskCompleteWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20177 mr.mock.ctrl.T.Helper() 20178 varargs := append([]interface{}{arg0, arg1}, arg2...) 20179 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilBundleTaskCompleteWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilBundleTaskCompleteWithContext), varargs...) 20180 } 20181 20182 // WaitUntilConversionTaskCancelled mocks base method 20183 func (m *MockEC2API) WaitUntilConversionTaskCancelled(arg0 *ec2.DescribeConversionTasksInput) error { 20184 m.ctrl.T.Helper() 20185 ret := m.ctrl.Call(m, "WaitUntilConversionTaskCancelled", arg0) 20186 ret0, _ := ret[0].(error) 20187 return ret0 20188 } 20189 20190 // WaitUntilConversionTaskCancelled indicates an expected call of WaitUntilConversionTaskCancelled 20191 func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCancelled(arg0 interface{}) *gomock.Call { 20192 mr.mock.ctrl.T.Helper() 20193 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCancelled), arg0) 20194 } 20195 20196 // WaitUntilConversionTaskCancelledWithContext mocks base method 20197 func (m *MockEC2API) WaitUntilConversionTaskCancelledWithContext(arg0 aws.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error { 20198 m.ctrl.T.Helper() 20199 varargs := []interface{}{arg0, arg1} 20200 for _, a := range arg2 { 20201 varargs = append(varargs, a) 20202 } 20203 ret := m.ctrl.Call(m, "WaitUntilConversionTaskCancelledWithContext", varargs...) 20204 ret0, _ := ret[0].(error) 20205 return ret0 20206 } 20207 20208 // WaitUntilConversionTaskCancelledWithContext indicates an expected call of WaitUntilConversionTaskCancelledWithContext 20209 func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCancelledWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20210 mr.mock.ctrl.T.Helper() 20211 varargs := append([]interface{}{arg0, arg1}, arg2...) 20212 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCancelledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCancelledWithContext), varargs...) 20213 } 20214 20215 // WaitUntilConversionTaskCompleted mocks base method 20216 func (m *MockEC2API) WaitUntilConversionTaskCompleted(arg0 *ec2.DescribeConversionTasksInput) error { 20217 m.ctrl.T.Helper() 20218 ret := m.ctrl.Call(m, "WaitUntilConversionTaskCompleted", arg0) 20219 ret0, _ := ret[0].(error) 20220 return ret0 20221 } 20222 20223 // WaitUntilConversionTaskCompleted indicates an expected call of WaitUntilConversionTaskCompleted 20224 func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCompleted(arg0 interface{}) *gomock.Call { 20225 mr.mock.ctrl.T.Helper() 20226 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCompleted), arg0) 20227 } 20228 20229 // WaitUntilConversionTaskCompletedWithContext mocks base method 20230 func (m *MockEC2API) WaitUntilConversionTaskCompletedWithContext(arg0 aws.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error { 20231 m.ctrl.T.Helper() 20232 varargs := []interface{}{arg0, arg1} 20233 for _, a := range arg2 { 20234 varargs = append(varargs, a) 20235 } 20236 ret := m.ctrl.Call(m, "WaitUntilConversionTaskCompletedWithContext", varargs...) 20237 ret0, _ := ret[0].(error) 20238 return ret0 20239 } 20240 20241 // WaitUntilConversionTaskCompletedWithContext indicates an expected call of WaitUntilConversionTaskCompletedWithContext 20242 func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskCompletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20243 mr.mock.ctrl.T.Helper() 20244 varargs := append([]interface{}{arg0, arg1}, arg2...) 20245 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskCompletedWithContext), varargs...) 20246 } 20247 20248 // WaitUntilConversionTaskDeleted mocks base method 20249 func (m *MockEC2API) WaitUntilConversionTaskDeleted(arg0 *ec2.DescribeConversionTasksInput) error { 20250 m.ctrl.T.Helper() 20251 ret := m.ctrl.Call(m, "WaitUntilConversionTaskDeleted", arg0) 20252 ret0, _ := ret[0].(error) 20253 return ret0 20254 } 20255 20256 // WaitUntilConversionTaskDeleted indicates an expected call of WaitUntilConversionTaskDeleted 20257 func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskDeleted(arg0 interface{}) *gomock.Call { 20258 mr.mock.ctrl.T.Helper() 20259 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskDeleted), arg0) 20260 } 20261 20262 // WaitUntilConversionTaskDeletedWithContext mocks base method 20263 func (m *MockEC2API) WaitUntilConversionTaskDeletedWithContext(arg0 aws.Context, arg1 *ec2.DescribeConversionTasksInput, arg2 ...request.WaiterOption) error { 20264 m.ctrl.T.Helper() 20265 varargs := []interface{}{arg0, arg1} 20266 for _, a := range arg2 { 20267 varargs = append(varargs, a) 20268 } 20269 ret := m.ctrl.Call(m, "WaitUntilConversionTaskDeletedWithContext", varargs...) 20270 ret0, _ := ret[0].(error) 20271 return ret0 20272 } 20273 20274 // WaitUntilConversionTaskDeletedWithContext indicates an expected call of WaitUntilConversionTaskDeletedWithContext 20275 func (mr *MockEC2APIMockRecorder) WaitUntilConversionTaskDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20276 mr.mock.ctrl.T.Helper() 20277 varargs := append([]interface{}{arg0, arg1}, arg2...) 20278 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilConversionTaskDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilConversionTaskDeletedWithContext), varargs...) 20279 } 20280 20281 // WaitUntilCustomerGatewayAvailable mocks base method 20282 func (m *MockEC2API) WaitUntilCustomerGatewayAvailable(arg0 *ec2.DescribeCustomerGatewaysInput) error { 20283 m.ctrl.T.Helper() 20284 ret := m.ctrl.Call(m, "WaitUntilCustomerGatewayAvailable", arg0) 20285 ret0, _ := ret[0].(error) 20286 return ret0 20287 } 20288 20289 // WaitUntilCustomerGatewayAvailable indicates an expected call of WaitUntilCustomerGatewayAvailable 20290 func (mr *MockEC2APIMockRecorder) WaitUntilCustomerGatewayAvailable(arg0 interface{}) *gomock.Call { 20291 mr.mock.ctrl.T.Helper() 20292 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCustomerGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailable), arg0) 20293 } 20294 20295 // WaitUntilCustomerGatewayAvailableWithContext mocks base method 20296 func (m *MockEC2API) WaitUntilCustomerGatewayAvailableWithContext(arg0 aws.Context, arg1 *ec2.DescribeCustomerGatewaysInput, arg2 ...request.WaiterOption) error { 20297 m.ctrl.T.Helper() 20298 varargs := []interface{}{arg0, arg1} 20299 for _, a := range arg2 { 20300 varargs = append(varargs, a) 20301 } 20302 ret := m.ctrl.Call(m, "WaitUntilCustomerGatewayAvailableWithContext", varargs...) 20303 ret0, _ := ret[0].(error) 20304 return ret0 20305 } 20306 20307 // WaitUntilCustomerGatewayAvailableWithContext indicates an expected call of WaitUntilCustomerGatewayAvailableWithContext 20308 func (mr *MockEC2APIMockRecorder) WaitUntilCustomerGatewayAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20309 mr.mock.ctrl.T.Helper() 20310 varargs := append([]interface{}{arg0, arg1}, arg2...) 20311 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilCustomerGatewayAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilCustomerGatewayAvailableWithContext), varargs...) 20312 } 20313 20314 // WaitUntilExportTaskCancelled mocks base method 20315 func (m *MockEC2API) WaitUntilExportTaskCancelled(arg0 *ec2.DescribeExportTasksInput) error { 20316 m.ctrl.T.Helper() 20317 ret := m.ctrl.Call(m, "WaitUntilExportTaskCancelled", arg0) 20318 ret0, _ := ret[0].(error) 20319 return ret0 20320 } 20321 20322 // WaitUntilExportTaskCancelled indicates an expected call of WaitUntilExportTaskCancelled 20323 func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCancelled(arg0 interface{}) *gomock.Call { 20324 mr.mock.ctrl.T.Helper() 20325 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCancelled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCancelled), arg0) 20326 } 20327 20328 // WaitUntilExportTaskCancelledWithContext mocks base method 20329 func (m *MockEC2API) WaitUntilExportTaskCancelledWithContext(arg0 aws.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.WaiterOption) error { 20330 m.ctrl.T.Helper() 20331 varargs := []interface{}{arg0, arg1} 20332 for _, a := range arg2 { 20333 varargs = append(varargs, a) 20334 } 20335 ret := m.ctrl.Call(m, "WaitUntilExportTaskCancelledWithContext", varargs...) 20336 ret0, _ := ret[0].(error) 20337 return ret0 20338 } 20339 20340 // WaitUntilExportTaskCancelledWithContext indicates an expected call of WaitUntilExportTaskCancelledWithContext 20341 func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCancelledWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20342 mr.mock.ctrl.T.Helper() 20343 varargs := append([]interface{}{arg0, arg1}, arg2...) 20344 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCancelledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCancelledWithContext), varargs...) 20345 } 20346 20347 // WaitUntilExportTaskCompleted mocks base method 20348 func (m *MockEC2API) WaitUntilExportTaskCompleted(arg0 *ec2.DescribeExportTasksInput) error { 20349 m.ctrl.T.Helper() 20350 ret := m.ctrl.Call(m, "WaitUntilExportTaskCompleted", arg0) 20351 ret0, _ := ret[0].(error) 20352 return ret0 20353 } 20354 20355 // WaitUntilExportTaskCompleted indicates an expected call of WaitUntilExportTaskCompleted 20356 func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCompleted(arg0 interface{}) *gomock.Call { 20357 mr.mock.ctrl.T.Helper() 20358 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCompleted), arg0) 20359 } 20360 20361 // WaitUntilExportTaskCompletedWithContext mocks base method 20362 func (m *MockEC2API) WaitUntilExportTaskCompletedWithContext(arg0 aws.Context, arg1 *ec2.DescribeExportTasksInput, arg2 ...request.WaiterOption) error { 20363 m.ctrl.T.Helper() 20364 varargs := []interface{}{arg0, arg1} 20365 for _, a := range arg2 { 20366 varargs = append(varargs, a) 20367 } 20368 ret := m.ctrl.Call(m, "WaitUntilExportTaskCompletedWithContext", varargs...) 20369 ret0, _ := ret[0].(error) 20370 return ret0 20371 } 20372 20373 // WaitUntilExportTaskCompletedWithContext indicates an expected call of WaitUntilExportTaskCompletedWithContext 20374 func (mr *MockEC2APIMockRecorder) WaitUntilExportTaskCompletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20375 mr.mock.ctrl.T.Helper() 20376 varargs := append([]interface{}{arg0, arg1}, arg2...) 20377 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilExportTaskCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilExportTaskCompletedWithContext), varargs...) 20378 } 20379 20380 // WaitUntilImageAvailable mocks base method 20381 func (m *MockEC2API) WaitUntilImageAvailable(arg0 *ec2.DescribeImagesInput) error { 20382 m.ctrl.T.Helper() 20383 ret := m.ctrl.Call(m, "WaitUntilImageAvailable", arg0) 20384 ret0, _ := ret[0].(error) 20385 return ret0 20386 } 20387 20388 // WaitUntilImageAvailable indicates an expected call of WaitUntilImageAvailable 20389 func (mr *MockEC2APIMockRecorder) WaitUntilImageAvailable(arg0 interface{}) *gomock.Call { 20390 mr.mock.ctrl.T.Helper() 20391 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageAvailable), arg0) 20392 } 20393 20394 // WaitUntilImageAvailableWithContext mocks base method 20395 func (m *MockEC2API) WaitUntilImageAvailableWithContext(arg0 aws.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.WaiterOption) error { 20396 m.ctrl.T.Helper() 20397 varargs := []interface{}{arg0, arg1} 20398 for _, a := range arg2 { 20399 varargs = append(varargs, a) 20400 } 20401 ret := m.ctrl.Call(m, "WaitUntilImageAvailableWithContext", varargs...) 20402 ret0, _ := ret[0].(error) 20403 return ret0 20404 } 20405 20406 // WaitUntilImageAvailableWithContext indicates an expected call of WaitUntilImageAvailableWithContext 20407 func (mr *MockEC2APIMockRecorder) WaitUntilImageAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20408 mr.mock.ctrl.T.Helper() 20409 varargs := append([]interface{}{arg0, arg1}, arg2...) 20410 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageAvailableWithContext), varargs...) 20411 } 20412 20413 // WaitUntilImageExists mocks base method 20414 func (m *MockEC2API) WaitUntilImageExists(arg0 *ec2.DescribeImagesInput) error { 20415 m.ctrl.T.Helper() 20416 ret := m.ctrl.Call(m, "WaitUntilImageExists", arg0) 20417 ret0, _ := ret[0].(error) 20418 return ret0 20419 } 20420 20421 // WaitUntilImageExists indicates an expected call of WaitUntilImageExists 20422 func (mr *MockEC2APIMockRecorder) WaitUntilImageExists(arg0 interface{}) *gomock.Call { 20423 mr.mock.ctrl.T.Helper() 20424 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageExists), arg0) 20425 } 20426 20427 // WaitUntilImageExistsWithContext mocks base method 20428 func (m *MockEC2API) WaitUntilImageExistsWithContext(arg0 aws.Context, arg1 *ec2.DescribeImagesInput, arg2 ...request.WaiterOption) error { 20429 m.ctrl.T.Helper() 20430 varargs := []interface{}{arg0, arg1} 20431 for _, a := range arg2 { 20432 varargs = append(varargs, a) 20433 } 20434 ret := m.ctrl.Call(m, "WaitUntilImageExistsWithContext", varargs...) 20435 ret0, _ := ret[0].(error) 20436 return ret0 20437 } 20438 20439 // WaitUntilImageExistsWithContext indicates an expected call of WaitUntilImageExistsWithContext 20440 func (mr *MockEC2APIMockRecorder) WaitUntilImageExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20441 mr.mock.ctrl.T.Helper() 20442 varargs := append([]interface{}{arg0, arg1}, arg2...) 20443 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilImageExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilImageExistsWithContext), varargs...) 20444 } 20445 20446 // WaitUntilInstanceExists mocks base method 20447 func (m *MockEC2API) WaitUntilInstanceExists(arg0 *ec2.DescribeInstancesInput) error { 20448 m.ctrl.T.Helper() 20449 ret := m.ctrl.Call(m, "WaitUntilInstanceExists", arg0) 20450 ret0, _ := ret[0].(error) 20451 return ret0 20452 } 20453 20454 // WaitUntilInstanceExists indicates an expected call of WaitUntilInstanceExists 20455 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceExists(arg0 interface{}) *gomock.Call { 20456 mr.mock.ctrl.T.Helper() 20457 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceExists), arg0) 20458 } 20459 20460 // WaitUntilInstanceExistsWithContext mocks base method 20461 func (m *MockEC2API) WaitUntilInstanceExistsWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error { 20462 m.ctrl.T.Helper() 20463 varargs := []interface{}{arg0, arg1} 20464 for _, a := range arg2 { 20465 varargs = append(varargs, a) 20466 } 20467 ret := m.ctrl.Call(m, "WaitUntilInstanceExistsWithContext", varargs...) 20468 ret0, _ := ret[0].(error) 20469 return ret0 20470 } 20471 20472 // WaitUntilInstanceExistsWithContext indicates an expected call of WaitUntilInstanceExistsWithContext 20473 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20474 mr.mock.ctrl.T.Helper() 20475 varargs := append([]interface{}{arg0, arg1}, arg2...) 20476 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceExistsWithContext), varargs...) 20477 } 20478 20479 // WaitUntilInstanceRunning mocks base method 20480 func (m *MockEC2API) WaitUntilInstanceRunning(arg0 *ec2.DescribeInstancesInput) error { 20481 m.ctrl.T.Helper() 20482 ret := m.ctrl.Call(m, "WaitUntilInstanceRunning", arg0) 20483 ret0, _ := ret[0].(error) 20484 return ret0 20485 } 20486 20487 // WaitUntilInstanceRunning indicates an expected call of WaitUntilInstanceRunning 20488 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceRunning(arg0 interface{}) *gomock.Call { 20489 mr.mock.ctrl.T.Helper() 20490 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceRunning", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceRunning), arg0) 20491 } 20492 20493 // WaitUntilInstanceRunningWithContext mocks base method 20494 func (m *MockEC2API) WaitUntilInstanceRunningWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error { 20495 m.ctrl.T.Helper() 20496 varargs := []interface{}{arg0, arg1} 20497 for _, a := range arg2 { 20498 varargs = append(varargs, a) 20499 } 20500 ret := m.ctrl.Call(m, "WaitUntilInstanceRunningWithContext", varargs...) 20501 ret0, _ := ret[0].(error) 20502 return ret0 20503 } 20504 20505 // WaitUntilInstanceRunningWithContext indicates an expected call of WaitUntilInstanceRunningWithContext 20506 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceRunningWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20507 mr.mock.ctrl.T.Helper() 20508 varargs := append([]interface{}{arg0, arg1}, arg2...) 20509 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceRunningWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceRunningWithContext), varargs...) 20510 } 20511 20512 // WaitUntilInstanceStatusOk mocks base method 20513 func (m *MockEC2API) WaitUntilInstanceStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error { 20514 m.ctrl.T.Helper() 20515 ret := m.ctrl.Call(m, "WaitUntilInstanceStatusOk", arg0) 20516 ret0, _ := ret[0].(error) 20517 return ret0 20518 } 20519 20520 // WaitUntilInstanceStatusOk indicates an expected call of WaitUntilInstanceStatusOk 20521 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStatusOk(arg0 interface{}) *gomock.Call { 20522 mr.mock.ctrl.T.Helper() 20523 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStatusOk), arg0) 20524 } 20525 20526 // WaitUntilInstanceStatusOkWithContext mocks base method 20527 func (m *MockEC2API) WaitUntilInstanceStatusOkWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.WaiterOption) error { 20528 m.ctrl.T.Helper() 20529 varargs := []interface{}{arg0, arg1} 20530 for _, a := range arg2 { 20531 varargs = append(varargs, a) 20532 } 20533 ret := m.ctrl.Call(m, "WaitUntilInstanceStatusOkWithContext", varargs...) 20534 ret0, _ := ret[0].(error) 20535 return ret0 20536 } 20537 20538 // WaitUntilInstanceStatusOkWithContext indicates an expected call of WaitUntilInstanceStatusOkWithContext 20539 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStatusOkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20540 mr.mock.ctrl.T.Helper() 20541 varargs := append([]interface{}{arg0, arg1}, arg2...) 20542 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStatusOkWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStatusOkWithContext), varargs...) 20543 } 20544 20545 // WaitUntilInstanceStopped mocks base method 20546 func (m *MockEC2API) WaitUntilInstanceStopped(arg0 *ec2.DescribeInstancesInput) error { 20547 m.ctrl.T.Helper() 20548 ret := m.ctrl.Call(m, "WaitUntilInstanceStopped", arg0) 20549 ret0, _ := ret[0].(error) 20550 return ret0 20551 } 20552 20553 // WaitUntilInstanceStopped indicates an expected call of WaitUntilInstanceStopped 20554 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStopped(arg0 interface{}) *gomock.Call { 20555 mr.mock.ctrl.T.Helper() 20556 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStopped", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStopped), arg0) 20557 } 20558 20559 // WaitUntilInstanceStoppedWithContext mocks base method 20560 func (m *MockEC2API) WaitUntilInstanceStoppedWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error { 20561 m.ctrl.T.Helper() 20562 varargs := []interface{}{arg0, arg1} 20563 for _, a := range arg2 { 20564 varargs = append(varargs, a) 20565 } 20566 ret := m.ctrl.Call(m, "WaitUntilInstanceStoppedWithContext", varargs...) 20567 ret0, _ := ret[0].(error) 20568 return ret0 20569 } 20570 20571 // WaitUntilInstanceStoppedWithContext indicates an expected call of WaitUntilInstanceStoppedWithContext 20572 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceStoppedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20573 mr.mock.ctrl.T.Helper() 20574 varargs := append([]interface{}{arg0, arg1}, arg2...) 20575 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceStoppedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceStoppedWithContext), varargs...) 20576 } 20577 20578 // WaitUntilInstanceTerminated mocks base method 20579 func (m *MockEC2API) WaitUntilInstanceTerminated(arg0 *ec2.DescribeInstancesInput) error { 20580 m.ctrl.T.Helper() 20581 ret := m.ctrl.Call(m, "WaitUntilInstanceTerminated", arg0) 20582 ret0, _ := ret[0].(error) 20583 return ret0 20584 } 20585 20586 // WaitUntilInstanceTerminated indicates an expected call of WaitUntilInstanceTerminated 20587 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceTerminated(arg0 interface{}) *gomock.Call { 20588 mr.mock.ctrl.T.Helper() 20589 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceTerminated", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceTerminated), arg0) 20590 } 20591 20592 // WaitUntilInstanceTerminatedWithContext mocks base method 20593 func (m *MockEC2API) WaitUntilInstanceTerminatedWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstancesInput, arg2 ...request.WaiterOption) error { 20594 m.ctrl.T.Helper() 20595 varargs := []interface{}{arg0, arg1} 20596 for _, a := range arg2 { 20597 varargs = append(varargs, a) 20598 } 20599 ret := m.ctrl.Call(m, "WaitUntilInstanceTerminatedWithContext", varargs...) 20600 ret0, _ := ret[0].(error) 20601 return ret0 20602 } 20603 20604 // WaitUntilInstanceTerminatedWithContext indicates an expected call of WaitUntilInstanceTerminatedWithContext 20605 func (mr *MockEC2APIMockRecorder) WaitUntilInstanceTerminatedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20606 mr.mock.ctrl.T.Helper() 20607 varargs := append([]interface{}{arg0, arg1}, arg2...) 20608 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilInstanceTerminatedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilInstanceTerminatedWithContext), varargs...) 20609 } 20610 20611 // WaitUntilKeyPairExists mocks base method 20612 func (m *MockEC2API) WaitUntilKeyPairExists(arg0 *ec2.DescribeKeyPairsInput) error { 20613 m.ctrl.T.Helper() 20614 ret := m.ctrl.Call(m, "WaitUntilKeyPairExists", arg0) 20615 ret0, _ := ret[0].(error) 20616 return ret0 20617 } 20618 20619 // WaitUntilKeyPairExists indicates an expected call of WaitUntilKeyPairExists 20620 func (mr *MockEC2APIMockRecorder) WaitUntilKeyPairExists(arg0 interface{}) *gomock.Call { 20621 mr.mock.ctrl.T.Helper() 20622 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilKeyPairExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilKeyPairExists), arg0) 20623 } 20624 20625 // WaitUntilKeyPairExistsWithContext mocks base method 20626 func (m *MockEC2API) WaitUntilKeyPairExistsWithContext(arg0 aws.Context, arg1 *ec2.DescribeKeyPairsInput, arg2 ...request.WaiterOption) error { 20627 m.ctrl.T.Helper() 20628 varargs := []interface{}{arg0, arg1} 20629 for _, a := range arg2 { 20630 varargs = append(varargs, a) 20631 } 20632 ret := m.ctrl.Call(m, "WaitUntilKeyPairExistsWithContext", varargs...) 20633 ret0, _ := ret[0].(error) 20634 return ret0 20635 } 20636 20637 // WaitUntilKeyPairExistsWithContext indicates an expected call of WaitUntilKeyPairExistsWithContext 20638 func (mr *MockEC2APIMockRecorder) WaitUntilKeyPairExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20639 mr.mock.ctrl.T.Helper() 20640 varargs := append([]interface{}{arg0, arg1}, arg2...) 20641 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilKeyPairExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilKeyPairExistsWithContext), varargs...) 20642 } 20643 20644 // WaitUntilNatGatewayAvailable mocks base method 20645 func (m *MockEC2API) WaitUntilNatGatewayAvailable(arg0 *ec2.DescribeNatGatewaysInput) error { 20646 m.ctrl.T.Helper() 20647 ret := m.ctrl.Call(m, "WaitUntilNatGatewayAvailable", arg0) 20648 ret0, _ := ret[0].(error) 20649 return ret0 20650 } 20651 20652 // WaitUntilNatGatewayAvailable indicates an expected call of WaitUntilNatGatewayAvailable 20653 func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayAvailable(arg0 interface{}) *gomock.Call { 20654 mr.mock.ctrl.T.Helper() 20655 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayAvailable), arg0) 20656 } 20657 20658 // WaitUntilNatGatewayAvailableWithContext mocks base method 20659 func (m *MockEC2API) WaitUntilNatGatewayAvailableWithContext(arg0 aws.Context, arg1 *ec2.DescribeNatGatewaysInput, arg2 ...request.WaiterOption) error { 20660 m.ctrl.T.Helper() 20661 varargs := []interface{}{arg0, arg1} 20662 for _, a := range arg2 { 20663 varargs = append(varargs, a) 20664 } 20665 ret := m.ctrl.Call(m, "WaitUntilNatGatewayAvailableWithContext", varargs...) 20666 ret0, _ := ret[0].(error) 20667 return ret0 20668 } 20669 20670 // WaitUntilNatGatewayAvailableWithContext indicates an expected call of WaitUntilNatGatewayAvailableWithContext 20671 func (mr *MockEC2APIMockRecorder) WaitUntilNatGatewayAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20672 mr.mock.ctrl.T.Helper() 20673 varargs := append([]interface{}{arg0, arg1}, arg2...) 20674 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNatGatewayAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNatGatewayAvailableWithContext), varargs...) 20675 } 20676 20677 // WaitUntilNetworkInterfaceAvailable mocks base method 20678 func (m *MockEC2API) WaitUntilNetworkInterfaceAvailable(arg0 *ec2.DescribeNetworkInterfacesInput) error { 20679 m.ctrl.T.Helper() 20680 ret := m.ctrl.Call(m, "WaitUntilNetworkInterfaceAvailable", arg0) 20681 ret0, _ := ret[0].(error) 20682 return ret0 20683 } 20684 20685 // WaitUntilNetworkInterfaceAvailable indicates an expected call of WaitUntilNetworkInterfaceAvailable 20686 func (mr *MockEC2APIMockRecorder) WaitUntilNetworkInterfaceAvailable(arg0 interface{}) *gomock.Call { 20687 mr.mock.ctrl.T.Helper() 20688 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNetworkInterfaceAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailable), arg0) 20689 } 20690 20691 // WaitUntilNetworkInterfaceAvailableWithContext mocks base method 20692 func (m *MockEC2API) WaitUntilNetworkInterfaceAvailableWithContext(arg0 aws.Context, arg1 *ec2.DescribeNetworkInterfacesInput, arg2 ...request.WaiterOption) error { 20693 m.ctrl.T.Helper() 20694 varargs := []interface{}{arg0, arg1} 20695 for _, a := range arg2 { 20696 varargs = append(varargs, a) 20697 } 20698 ret := m.ctrl.Call(m, "WaitUntilNetworkInterfaceAvailableWithContext", varargs...) 20699 ret0, _ := ret[0].(error) 20700 return ret0 20701 } 20702 20703 // WaitUntilNetworkInterfaceAvailableWithContext indicates an expected call of WaitUntilNetworkInterfaceAvailableWithContext 20704 func (mr *MockEC2APIMockRecorder) WaitUntilNetworkInterfaceAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20705 mr.mock.ctrl.T.Helper() 20706 varargs := append([]interface{}{arg0, arg1}, arg2...) 20707 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilNetworkInterfaceAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilNetworkInterfaceAvailableWithContext), varargs...) 20708 } 20709 20710 // WaitUntilPasswordDataAvailable mocks base method 20711 func (m *MockEC2API) WaitUntilPasswordDataAvailable(arg0 *ec2.GetPasswordDataInput) error { 20712 m.ctrl.T.Helper() 20713 ret := m.ctrl.Call(m, "WaitUntilPasswordDataAvailable", arg0) 20714 ret0, _ := ret[0].(error) 20715 return ret0 20716 } 20717 20718 // WaitUntilPasswordDataAvailable indicates an expected call of WaitUntilPasswordDataAvailable 20719 func (mr *MockEC2APIMockRecorder) WaitUntilPasswordDataAvailable(arg0 interface{}) *gomock.Call { 20720 mr.mock.ctrl.T.Helper() 20721 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPasswordDataAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilPasswordDataAvailable), arg0) 20722 } 20723 20724 // WaitUntilPasswordDataAvailableWithContext mocks base method 20725 func (m *MockEC2API) WaitUntilPasswordDataAvailableWithContext(arg0 aws.Context, arg1 *ec2.GetPasswordDataInput, arg2 ...request.WaiterOption) error { 20726 m.ctrl.T.Helper() 20727 varargs := []interface{}{arg0, arg1} 20728 for _, a := range arg2 { 20729 varargs = append(varargs, a) 20730 } 20731 ret := m.ctrl.Call(m, "WaitUntilPasswordDataAvailableWithContext", varargs...) 20732 ret0, _ := ret[0].(error) 20733 return ret0 20734 } 20735 20736 // WaitUntilPasswordDataAvailableWithContext indicates an expected call of WaitUntilPasswordDataAvailableWithContext 20737 func (mr *MockEC2APIMockRecorder) WaitUntilPasswordDataAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20738 mr.mock.ctrl.T.Helper() 20739 varargs := append([]interface{}{arg0, arg1}, arg2...) 20740 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilPasswordDataAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilPasswordDataAvailableWithContext), varargs...) 20741 } 20742 20743 // WaitUntilSnapshotCompleted mocks base method 20744 func (m *MockEC2API) WaitUntilSnapshotCompleted(arg0 *ec2.DescribeSnapshotsInput) error { 20745 m.ctrl.T.Helper() 20746 ret := m.ctrl.Call(m, "WaitUntilSnapshotCompleted", arg0) 20747 ret0, _ := ret[0].(error) 20748 return ret0 20749 } 20750 20751 // WaitUntilSnapshotCompleted indicates an expected call of WaitUntilSnapshotCompleted 20752 func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotCompleted(arg0 interface{}) *gomock.Call { 20753 mr.mock.ctrl.T.Helper() 20754 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompleted), arg0) 20755 } 20756 20757 // WaitUntilSnapshotCompletedWithContext mocks base method 20758 func (m *MockEC2API) WaitUntilSnapshotCompletedWithContext(arg0 aws.Context, arg1 *ec2.DescribeSnapshotsInput, arg2 ...request.WaiterOption) error { 20759 m.ctrl.T.Helper() 20760 varargs := []interface{}{arg0, arg1} 20761 for _, a := range arg2 { 20762 varargs = append(varargs, a) 20763 } 20764 ret := m.ctrl.Call(m, "WaitUntilSnapshotCompletedWithContext", varargs...) 20765 ret0, _ := ret[0].(error) 20766 return ret0 20767 } 20768 20769 // WaitUntilSnapshotCompletedWithContext indicates an expected call of WaitUntilSnapshotCompletedWithContext 20770 func (mr *MockEC2APIMockRecorder) WaitUntilSnapshotCompletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20771 mr.mock.ctrl.T.Helper() 20772 varargs := append([]interface{}{arg0, arg1}, arg2...) 20773 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSnapshotCompletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSnapshotCompletedWithContext), varargs...) 20774 } 20775 20776 // WaitUntilSpotInstanceRequestFulfilled mocks base method 20777 func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilled(arg0 *ec2.DescribeSpotInstanceRequestsInput) error { 20778 m.ctrl.T.Helper() 20779 ret := m.ctrl.Call(m, "WaitUntilSpotInstanceRequestFulfilled", arg0) 20780 ret0, _ := ret[0].(error) 20781 return ret0 20782 } 20783 20784 // WaitUntilSpotInstanceRequestFulfilled indicates an expected call of WaitUntilSpotInstanceRequestFulfilled 20785 func (mr *MockEC2APIMockRecorder) WaitUntilSpotInstanceRequestFulfilled(arg0 interface{}) *gomock.Call { 20786 mr.mock.ctrl.T.Helper() 20787 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSpotInstanceRequestFulfilled", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilled), arg0) 20788 } 20789 20790 // WaitUntilSpotInstanceRequestFulfilledWithContext mocks base method 20791 func (m *MockEC2API) WaitUntilSpotInstanceRequestFulfilledWithContext(arg0 aws.Context, arg1 *ec2.DescribeSpotInstanceRequestsInput, arg2 ...request.WaiterOption) error { 20792 m.ctrl.T.Helper() 20793 varargs := []interface{}{arg0, arg1} 20794 for _, a := range arg2 { 20795 varargs = append(varargs, a) 20796 } 20797 ret := m.ctrl.Call(m, "WaitUntilSpotInstanceRequestFulfilledWithContext", varargs...) 20798 ret0, _ := ret[0].(error) 20799 return ret0 20800 } 20801 20802 // WaitUntilSpotInstanceRequestFulfilledWithContext indicates an expected call of WaitUntilSpotInstanceRequestFulfilledWithContext 20803 func (mr *MockEC2APIMockRecorder) WaitUntilSpotInstanceRequestFulfilledWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20804 mr.mock.ctrl.T.Helper() 20805 varargs := append([]interface{}{arg0, arg1}, arg2...) 20806 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSpotInstanceRequestFulfilledWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSpotInstanceRequestFulfilledWithContext), varargs...) 20807 } 20808 20809 // WaitUntilSubnetAvailable mocks base method 20810 func (m *MockEC2API) WaitUntilSubnetAvailable(arg0 *ec2.DescribeSubnetsInput) error { 20811 m.ctrl.T.Helper() 20812 ret := m.ctrl.Call(m, "WaitUntilSubnetAvailable", arg0) 20813 ret0, _ := ret[0].(error) 20814 return ret0 20815 } 20816 20817 // WaitUntilSubnetAvailable indicates an expected call of WaitUntilSubnetAvailable 20818 func (mr *MockEC2APIMockRecorder) WaitUntilSubnetAvailable(arg0 interface{}) *gomock.Call { 20819 mr.mock.ctrl.T.Helper() 20820 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSubnetAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSubnetAvailable), arg0) 20821 } 20822 20823 // WaitUntilSubnetAvailableWithContext mocks base method 20824 func (m *MockEC2API) WaitUntilSubnetAvailableWithContext(arg0 aws.Context, arg1 *ec2.DescribeSubnetsInput, arg2 ...request.WaiterOption) error { 20825 m.ctrl.T.Helper() 20826 varargs := []interface{}{arg0, arg1} 20827 for _, a := range arg2 { 20828 varargs = append(varargs, a) 20829 } 20830 ret := m.ctrl.Call(m, "WaitUntilSubnetAvailableWithContext", varargs...) 20831 ret0, _ := ret[0].(error) 20832 return ret0 20833 } 20834 20835 // WaitUntilSubnetAvailableWithContext indicates an expected call of WaitUntilSubnetAvailableWithContext 20836 func (mr *MockEC2APIMockRecorder) WaitUntilSubnetAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20837 mr.mock.ctrl.T.Helper() 20838 varargs := append([]interface{}{arg0, arg1}, arg2...) 20839 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSubnetAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSubnetAvailableWithContext), varargs...) 20840 } 20841 20842 // WaitUntilSystemStatusOk mocks base method 20843 func (m *MockEC2API) WaitUntilSystemStatusOk(arg0 *ec2.DescribeInstanceStatusInput) error { 20844 m.ctrl.T.Helper() 20845 ret := m.ctrl.Call(m, "WaitUntilSystemStatusOk", arg0) 20846 ret0, _ := ret[0].(error) 20847 return ret0 20848 } 20849 20850 // WaitUntilSystemStatusOk indicates an expected call of WaitUntilSystemStatusOk 20851 func (mr *MockEC2APIMockRecorder) WaitUntilSystemStatusOk(arg0 interface{}) *gomock.Call { 20852 mr.mock.ctrl.T.Helper() 20853 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSystemStatusOk", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSystemStatusOk), arg0) 20854 } 20855 20856 // WaitUntilSystemStatusOkWithContext mocks base method 20857 func (m *MockEC2API) WaitUntilSystemStatusOkWithContext(arg0 aws.Context, arg1 *ec2.DescribeInstanceStatusInput, arg2 ...request.WaiterOption) error { 20858 m.ctrl.T.Helper() 20859 varargs := []interface{}{arg0, arg1} 20860 for _, a := range arg2 { 20861 varargs = append(varargs, a) 20862 } 20863 ret := m.ctrl.Call(m, "WaitUntilSystemStatusOkWithContext", varargs...) 20864 ret0, _ := ret[0].(error) 20865 return ret0 20866 } 20867 20868 // WaitUntilSystemStatusOkWithContext indicates an expected call of WaitUntilSystemStatusOkWithContext 20869 func (mr *MockEC2APIMockRecorder) WaitUntilSystemStatusOkWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20870 mr.mock.ctrl.T.Helper() 20871 varargs := append([]interface{}{arg0, arg1}, arg2...) 20872 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilSystemStatusOkWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilSystemStatusOkWithContext), varargs...) 20873 } 20874 20875 // WaitUntilVolumeAvailable mocks base method 20876 func (m *MockEC2API) WaitUntilVolumeAvailable(arg0 *ec2.DescribeVolumesInput) error { 20877 m.ctrl.T.Helper() 20878 ret := m.ctrl.Call(m, "WaitUntilVolumeAvailable", arg0) 20879 ret0, _ := ret[0].(error) 20880 return ret0 20881 } 20882 20883 // WaitUntilVolumeAvailable indicates an expected call of WaitUntilVolumeAvailable 20884 func (mr *MockEC2APIMockRecorder) WaitUntilVolumeAvailable(arg0 interface{}) *gomock.Call { 20885 mr.mock.ctrl.T.Helper() 20886 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeAvailable), arg0) 20887 } 20888 20889 // WaitUntilVolumeAvailableWithContext mocks base method 20890 func (m *MockEC2API) WaitUntilVolumeAvailableWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error { 20891 m.ctrl.T.Helper() 20892 varargs := []interface{}{arg0, arg1} 20893 for _, a := range arg2 { 20894 varargs = append(varargs, a) 20895 } 20896 ret := m.ctrl.Call(m, "WaitUntilVolumeAvailableWithContext", varargs...) 20897 ret0, _ := ret[0].(error) 20898 return ret0 20899 } 20900 20901 // WaitUntilVolumeAvailableWithContext indicates an expected call of WaitUntilVolumeAvailableWithContext 20902 func (mr *MockEC2APIMockRecorder) WaitUntilVolumeAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20903 mr.mock.ctrl.T.Helper() 20904 varargs := append([]interface{}{arg0, arg1}, arg2...) 20905 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeAvailableWithContext), varargs...) 20906 } 20907 20908 // WaitUntilVolumeDeleted mocks base method 20909 func (m *MockEC2API) WaitUntilVolumeDeleted(arg0 *ec2.DescribeVolumesInput) error { 20910 m.ctrl.T.Helper() 20911 ret := m.ctrl.Call(m, "WaitUntilVolumeDeleted", arg0) 20912 ret0, _ := ret[0].(error) 20913 return ret0 20914 } 20915 20916 // WaitUntilVolumeDeleted indicates an expected call of WaitUntilVolumeDeleted 20917 func (mr *MockEC2APIMockRecorder) WaitUntilVolumeDeleted(arg0 interface{}) *gomock.Call { 20918 mr.mock.ctrl.T.Helper() 20919 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeDeleted), arg0) 20920 } 20921 20922 // WaitUntilVolumeDeletedWithContext mocks base method 20923 func (m *MockEC2API) WaitUntilVolumeDeletedWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error { 20924 m.ctrl.T.Helper() 20925 varargs := []interface{}{arg0, arg1} 20926 for _, a := range arg2 { 20927 varargs = append(varargs, a) 20928 } 20929 ret := m.ctrl.Call(m, "WaitUntilVolumeDeletedWithContext", varargs...) 20930 ret0, _ := ret[0].(error) 20931 return ret0 20932 } 20933 20934 // WaitUntilVolumeDeletedWithContext indicates an expected call of WaitUntilVolumeDeletedWithContext 20935 func (mr *MockEC2APIMockRecorder) WaitUntilVolumeDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20936 mr.mock.ctrl.T.Helper() 20937 varargs := append([]interface{}{arg0, arg1}, arg2...) 20938 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeDeletedWithContext), varargs...) 20939 } 20940 20941 // WaitUntilVolumeInUse mocks base method 20942 func (m *MockEC2API) WaitUntilVolumeInUse(arg0 *ec2.DescribeVolumesInput) error { 20943 m.ctrl.T.Helper() 20944 ret := m.ctrl.Call(m, "WaitUntilVolumeInUse", arg0) 20945 ret0, _ := ret[0].(error) 20946 return ret0 20947 } 20948 20949 // WaitUntilVolumeInUse indicates an expected call of WaitUntilVolumeInUse 20950 func (mr *MockEC2APIMockRecorder) WaitUntilVolumeInUse(arg0 interface{}) *gomock.Call { 20951 mr.mock.ctrl.T.Helper() 20952 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeInUse", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeInUse), arg0) 20953 } 20954 20955 // WaitUntilVolumeInUseWithContext mocks base method 20956 func (m *MockEC2API) WaitUntilVolumeInUseWithContext(arg0 aws.Context, arg1 *ec2.DescribeVolumesInput, arg2 ...request.WaiterOption) error { 20957 m.ctrl.T.Helper() 20958 varargs := []interface{}{arg0, arg1} 20959 for _, a := range arg2 { 20960 varargs = append(varargs, a) 20961 } 20962 ret := m.ctrl.Call(m, "WaitUntilVolumeInUseWithContext", varargs...) 20963 ret0, _ := ret[0].(error) 20964 return ret0 20965 } 20966 20967 // WaitUntilVolumeInUseWithContext indicates an expected call of WaitUntilVolumeInUseWithContext 20968 func (mr *MockEC2APIMockRecorder) WaitUntilVolumeInUseWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 20969 mr.mock.ctrl.T.Helper() 20970 varargs := append([]interface{}{arg0, arg1}, arg2...) 20971 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVolumeInUseWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVolumeInUseWithContext), varargs...) 20972 } 20973 20974 // WaitUntilVpcAvailable mocks base method 20975 func (m *MockEC2API) WaitUntilVpcAvailable(arg0 *ec2.DescribeVpcsInput) error { 20976 m.ctrl.T.Helper() 20977 ret := m.ctrl.Call(m, "WaitUntilVpcAvailable", arg0) 20978 ret0, _ := ret[0].(error) 20979 return ret0 20980 } 20981 20982 // WaitUntilVpcAvailable indicates an expected call of WaitUntilVpcAvailable 20983 func (mr *MockEC2APIMockRecorder) WaitUntilVpcAvailable(arg0 interface{}) *gomock.Call { 20984 mr.mock.ctrl.T.Helper() 20985 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcAvailable), arg0) 20986 } 20987 20988 // WaitUntilVpcAvailableWithContext mocks base method 20989 func (m *MockEC2API) WaitUntilVpcAvailableWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.WaiterOption) error { 20990 m.ctrl.T.Helper() 20991 varargs := []interface{}{arg0, arg1} 20992 for _, a := range arg2 { 20993 varargs = append(varargs, a) 20994 } 20995 ret := m.ctrl.Call(m, "WaitUntilVpcAvailableWithContext", varargs...) 20996 ret0, _ := ret[0].(error) 20997 return ret0 20998 } 20999 21000 // WaitUntilVpcAvailableWithContext indicates an expected call of WaitUntilVpcAvailableWithContext 21001 func (mr *MockEC2APIMockRecorder) WaitUntilVpcAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 21002 mr.mock.ctrl.T.Helper() 21003 varargs := append([]interface{}{arg0, arg1}, arg2...) 21004 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcAvailableWithContext), varargs...) 21005 } 21006 21007 // WaitUntilVpcExists mocks base method 21008 func (m *MockEC2API) WaitUntilVpcExists(arg0 *ec2.DescribeVpcsInput) error { 21009 m.ctrl.T.Helper() 21010 ret := m.ctrl.Call(m, "WaitUntilVpcExists", arg0) 21011 ret0, _ := ret[0].(error) 21012 return ret0 21013 } 21014 21015 // WaitUntilVpcExists indicates an expected call of WaitUntilVpcExists 21016 func (mr *MockEC2APIMockRecorder) WaitUntilVpcExists(arg0 interface{}) *gomock.Call { 21017 mr.mock.ctrl.T.Helper() 21018 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcExists), arg0) 21019 } 21020 21021 // WaitUntilVpcExistsWithContext mocks base method 21022 func (m *MockEC2API) WaitUntilVpcExistsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcsInput, arg2 ...request.WaiterOption) error { 21023 m.ctrl.T.Helper() 21024 varargs := []interface{}{arg0, arg1} 21025 for _, a := range arg2 { 21026 varargs = append(varargs, a) 21027 } 21028 ret := m.ctrl.Call(m, "WaitUntilVpcExistsWithContext", varargs...) 21029 ret0, _ := ret[0].(error) 21030 return ret0 21031 } 21032 21033 // WaitUntilVpcExistsWithContext indicates an expected call of WaitUntilVpcExistsWithContext 21034 func (mr *MockEC2APIMockRecorder) WaitUntilVpcExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 21035 mr.mock.ctrl.T.Helper() 21036 varargs := append([]interface{}{arg0, arg1}, arg2...) 21037 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcExistsWithContext), varargs...) 21038 } 21039 21040 // WaitUntilVpcPeeringConnectionDeleted mocks base method 21041 func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeleted(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error { 21042 m.ctrl.T.Helper() 21043 ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionDeleted", arg0) 21044 ret0, _ := ret[0].(error) 21045 return ret0 21046 } 21047 21048 // WaitUntilVpcPeeringConnectionDeleted indicates an expected call of WaitUntilVpcPeeringConnectionDeleted 21049 func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionDeleted(arg0 interface{}) *gomock.Call { 21050 mr.mock.ctrl.T.Helper() 21051 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeleted), arg0) 21052 } 21053 21054 // WaitUntilVpcPeeringConnectionDeletedWithContext mocks base method 21055 func (m *MockEC2API) WaitUntilVpcPeeringConnectionDeletedWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.WaiterOption) error { 21056 m.ctrl.T.Helper() 21057 varargs := []interface{}{arg0, arg1} 21058 for _, a := range arg2 { 21059 varargs = append(varargs, a) 21060 } 21061 ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionDeletedWithContext", varargs...) 21062 ret0, _ := ret[0].(error) 21063 return ret0 21064 } 21065 21066 // WaitUntilVpcPeeringConnectionDeletedWithContext indicates an expected call of WaitUntilVpcPeeringConnectionDeletedWithContext 21067 func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 21068 mr.mock.ctrl.T.Helper() 21069 varargs := append([]interface{}{arg0, arg1}, arg2...) 21070 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionDeletedWithContext), varargs...) 21071 } 21072 21073 // WaitUntilVpcPeeringConnectionExists mocks base method 21074 func (m *MockEC2API) WaitUntilVpcPeeringConnectionExists(arg0 *ec2.DescribeVpcPeeringConnectionsInput) error { 21075 m.ctrl.T.Helper() 21076 ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionExists", arg0) 21077 ret0, _ := ret[0].(error) 21078 return ret0 21079 } 21080 21081 // WaitUntilVpcPeeringConnectionExists indicates an expected call of WaitUntilVpcPeeringConnectionExists 21082 func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionExists(arg0 interface{}) *gomock.Call { 21083 mr.mock.ctrl.T.Helper() 21084 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionExists", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExists), arg0) 21085 } 21086 21087 // WaitUntilVpcPeeringConnectionExistsWithContext mocks base method 21088 func (m *MockEC2API) WaitUntilVpcPeeringConnectionExistsWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpcPeeringConnectionsInput, arg2 ...request.WaiterOption) error { 21089 m.ctrl.T.Helper() 21090 varargs := []interface{}{arg0, arg1} 21091 for _, a := range arg2 { 21092 varargs = append(varargs, a) 21093 } 21094 ret := m.ctrl.Call(m, "WaitUntilVpcPeeringConnectionExistsWithContext", varargs...) 21095 ret0, _ := ret[0].(error) 21096 return ret0 21097 } 21098 21099 // WaitUntilVpcPeeringConnectionExistsWithContext indicates an expected call of WaitUntilVpcPeeringConnectionExistsWithContext 21100 func (mr *MockEC2APIMockRecorder) WaitUntilVpcPeeringConnectionExistsWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 21101 mr.mock.ctrl.T.Helper() 21102 varargs := append([]interface{}{arg0, arg1}, arg2...) 21103 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpcPeeringConnectionExistsWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpcPeeringConnectionExistsWithContext), varargs...) 21104 } 21105 21106 // WaitUntilVpnConnectionAvailable mocks base method 21107 func (m *MockEC2API) WaitUntilVpnConnectionAvailable(arg0 *ec2.DescribeVpnConnectionsInput) error { 21108 m.ctrl.T.Helper() 21109 ret := m.ctrl.Call(m, "WaitUntilVpnConnectionAvailable", arg0) 21110 ret0, _ := ret[0].(error) 21111 return ret0 21112 } 21113 21114 // WaitUntilVpnConnectionAvailable indicates an expected call of WaitUntilVpnConnectionAvailable 21115 func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailable(arg0 interface{}) *gomock.Call { 21116 mr.mock.ctrl.T.Helper() 21117 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailable", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailable), arg0) 21118 } 21119 21120 // WaitUntilVpnConnectionAvailableWithContext mocks base method 21121 func (m *MockEC2API) WaitUntilVpnConnectionAvailableWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.WaiterOption) error { 21122 m.ctrl.T.Helper() 21123 varargs := []interface{}{arg0, arg1} 21124 for _, a := range arg2 { 21125 varargs = append(varargs, a) 21126 } 21127 ret := m.ctrl.Call(m, "WaitUntilVpnConnectionAvailableWithContext", varargs...) 21128 ret0, _ := ret[0].(error) 21129 return ret0 21130 } 21131 21132 // WaitUntilVpnConnectionAvailableWithContext indicates an expected call of WaitUntilVpnConnectionAvailableWithContext 21133 func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionAvailableWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 21134 mr.mock.ctrl.T.Helper() 21135 varargs := append([]interface{}{arg0, arg1}, arg2...) 21136 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionAvailableWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionAvailableWithContext), varargs...) 21137 } 21138 21139 // WaitUntilVpnConnectionDeleted mocks base method 21140 func (m *MockEC2API) WaitUntilVpnConnectionDeleted(arg0 *ec2.DescribeVpnConnectionsInput) error { 21141 m.ctrl.T.Helper() 21142 ret := m.ctrl.Call(m, "WaitUntilVpnConnectionDeleted", arg0) 21143 ret0, _ := ret[0].(error) 21144 return ret0 21145 } 21146 21147 // WaitUntilVpnConnectionDeleted indicates an expected call of WaitUntilVpnConnectionDeleted 21148 func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeleted(arg0 interface{}) *gomock.Call { 21149 mr.mock.ctrl.T.Helper() 21150 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeleted", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeleted), arg0) 21151 } 21152 21153 // WaitUntilVpnConnectionDeletedWithContext mocks base method 21154 func (m *MockEC2API) WaitUntilVpnConnectionDeletedWithContext(arg0 aws.Context, arg1 *ec2.DescribeVpnConnectionsInput, arg2 ...request.WaiterOption) error { 21155 m.ctrl.T.Helper() 21156 varargs := []interface{}{arg0, arg1} 21157 for _, a := range arg2 { 21158 varargs = append(varargs, a) 21159 } 21160 ret := m.ctrl.Call(m, "WaitUntilVpnConnectionDeletedWithContext", varargs...) 21161 ret0, _ := ret[0].(error) 21162 return ret0 21163 } 21164 21165 // WaitUntilVpnConnectionDeletedWithContext indicates an expected call of WaitUntilVpnConnectionDeletedWithContext 21166 func (mr *MockEC2APIMockRecorder) WaitUntilVpnConnectionDeletedWithContext(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call { 21167 mr.mock.ctrl.T.Helper() 21168 varargs := append([]interface{}{arg0, arg1}, arg2...) 21169 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitUntilVpnConnectionDeletedWithContext", reflect.TypeOf((*MockEC2API)(nil).WaitUntilVpnConnectionDeletedWithContext), varargs...) 21170 }