internal/resources/providers/awslib/ec2/mock_client.go

// Licensed to Elasticsearch B.V. under one or more contributor
// license agreements. See the NOTICE file distributed with
// this work for additional information regarding copyright
// ownership. Elasticsearch B.V. licenses this file to you under
// the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

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

package ec2

import (
	context "context"

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

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

type MockClient_Expecter struct {
	mock *mock.Mock
}

func (_m *MockClient) EXPECT() *MockClient_Expecter {
	return &MockClient_Expecter{mock: &_m.Mock}
}

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

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

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

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

	return r0, r1
}

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

// CreateSnapshots is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceec2.CreateSnapshotsInput
//   - optFns ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) CreateSnapshots(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_CreateSnapshots_Call {
	return &MockClient_CreateSnapshots_Call{Call: _e.mock.On("CreateSnapshots",
		append([]interface{}{ctx, params}, optFns...)...)}
}

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

func (_c *MockClient_CreateSnapshots_Call) Return(_a0 *serviceec2.CreateSnapshotsOutput, _a1 error) *MockClient_CreateSnapshots_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_CreateSnapshots_Call) RunAndReturn(run func(context.Context, *serviceec2.CreateSnapshotsInput, ...func(*serviceec2.Options)) (*serviceec2.CreateSnapshotsOutput, error)) *MockClient_CreateSnapshots_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

// DeleteSnapshot is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceec2.DeleteSnapshotInput
//   - optFns ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DeleteSnapshot(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_DeleteSnapshot_Call {
	return &MockClient_DeleteSnapshot_Call{Call: _e.mock.On("DeleteSnapshot",
		append([]interface{}{ctx, params}, optFns...)...)}
}

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

func (_c *MockClient_DeleteSnapshot_Call) Return(_a0 *serviceec2.DeleteSnapshotOutput, _a1 error) *MockClient_DeleteSnapshot_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DeleteSnapshot_Call) RunAndReturn(run func(context.Context, *serviceec2.DeleteSnapshotInput, ...func(*serviceec2.Options)) (*serviceec2.DeleteSnapshotOutput, error)) *MockClient_DeleteSnapshot_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeFlowLogs provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeFlowLogs(_a0 context.Context, _a1 *serviceec2.DescribeFlowLogsInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeFlowLogsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeFlowLogsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeFlowLogsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeFlowLogsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeFlowLogsInput, ...func(*serviceec2.Options)) *serviceec2.DescribeFlowLogsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeFlowLogsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeFlowLogsInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeFlowLogs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeFlowLogsInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeFlowLogs(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeFlowLogs_Call {
	return &MockClient_DescribeFlowLogs_Call{Call: _e.mock.On("DescribeFlowLogs",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeFlowLogs_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeFlowLogsInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeFlowLogs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeFlowLogsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeFlowLogs_Call) Return(_a0 *serviceec2.DescribeFlowLogsOutput, _a1 error) *MockClient_DescribeFlowLogs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeFlowLogs_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeFlowLogsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeFlowLogsOutput, error)) *MockClient_DescribeFlowLogs_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInstances provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeInstances(_a0 context.Context, _a1 *serviceec2.DescribeInstancesInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeInstancesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeInstancesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeInstancesInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeInstancesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeInstancesInput, ...func(*serviceec2.Options)) *serviceec2.DescribeInstancesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeInstancesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeInstancesInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeInstances is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeInstancesInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeInstances(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeInstances_Call {
	return &MockClient_DescribeInstances_Call{Call: _e.mock.On("DescribeInstances",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeInstances_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeInstancesInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeInstances_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeInstancesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeInstances_Call) Return(_a0 *serviceec2.DescribeInstancesOutput, _a1 error) *MockClient_DescribeInstances_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeInstances_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeInstancesInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeInstancesOutput, error)) *MockClient_DescribeInstances_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeInternetGateways provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeInternetGateways(_a0 context.Context, _a1 *serviceec2.DescribeInternetGatewaysInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeInternetGatewaysOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeInternetGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeInternetGatewaysInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeInternetGatewaysOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeInternetGatewaysInput, ...func(*serviceec2.Options)) *serviceec2.DescribeInternetGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeInternetGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeInternetGatewaysInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeInternetGateways is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeInternetGatewaysInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeInternetGateways(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeInternetGateways_Call {
	return &MockClient_DescribeInternetGateways_Call{Call: _e.mock.On("DescribeInternetGateways",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeInternetGateways_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeInternetGatewaysInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeInternetGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeInternetGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeInternetGateways_Call) Return(_a0 *serviceec2.DescribeInternetGatewaysOutput, _a1 error) *MockClient_DescribeInternetGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeInternetGateways_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeInternetGatewaysInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeInternetGatewaysOutput, error)) *MockClient_DescribeInternetGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNatGateways provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeNatGateways(_a0 context.Context, _a1 *serviceec2.DescribeNatGatewaysInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeNatGatewaysOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeNatGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeNatGatewaysInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeNatGatewaysOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeNatGatewaysInput, ...func(*serviceec2.Options)) *serviceec2.DescribeNatGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeNatGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeNatGatewaysInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeNatGateways is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeNatGatewaysInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeNatGateways(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeNatGateways_Call {
	return &MockClient_DescribeNatGateways_Call{Call: _e.mock.On("DescribeNatGateways",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeNatGateways_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeNatGatewaysInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeNatGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeNatGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeNatGateways_Call) Return(_a0 *serviceec2.DescribeNatGatewaysOutput, _a1 error) *MockClient_DescribeNatGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeNatGateways_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeNatGatewaysInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeNatGatewaysOutput, error)) *MockClient_DescribeNatGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkAcls provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeNetworkAcls(_a0 context.Context, _a1 *serviceec2.DescribeNetworkAclsInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeNetworkAclsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeNetworkAclsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeNetworkAclsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeNetworkAclsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeNetworkAclsInput, ...func(*serviceec2.Options)) *serviceec2.DescribeNetworkAclsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeNetworkAclsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeNetworkAclsInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeNetworkAcls is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeNetworkAclsInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeNetworkAcls(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeNetworkAcls_Call {
	return &MockClient_DescribeNetworkAcls_Call{Call: _e.mock.On("DescribeNetworkAcls",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeNetworkAcls_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeNetworkAclsInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeNetworkAcls_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeNetworkAclsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeNetworkAcls_Call) Return(_a0 *serviceec2.DescribeNetworkAclsOutput, _a1 error) *MockClient_DescribeNetworkAcls_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeNetworkAcls_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeNetworkAclsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeNetworkAclsOutput, error)) *MockClient_DescribeNetworkAcls_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeNetworkInterfaces provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeNetworkInterfaces(_a0 context.Context, _a1 *serviceec2.DescribeNetworkInterfacesInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeNetworkInterfacesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeNetworkInterfacesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeNetworkInterfacesInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeNetworkInterfacesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeNetworkInterfacesInput, ...func(*serviceec2.Options)) *serviceec2.DescribeNetworkInterfacesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeNetworkInterfacesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeNetworkInterfacesInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeNetworkInterfaces is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeNetworkInterfacesInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeNetworkInterfaces(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeNetworkInterfaces_Call {
	return &MockClient_DescribeNetworkInterfaces_Call{Call: _e.mock.On("DescribeNetworkInterfaces",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeNetworkInterfaces_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeNetworkInterfacesInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeNetworkInterfaces_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeNetworkInterfacesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeNetworkInterfaces_Call) Return(_a0 *serviceec2.DescribeNetworkInterfacesOutput, _a1 error) *MockClient_DescribeNetworkInterfaces_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeNetworkInterfaces_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeNetworkInterfacesInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeNetworkInterfacesOutput, error)) *MockClient_DescribeNetworkInterfaces_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeRouteTables provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeRouteTables(_a0 context.Context, _a1 *serviceec2.DescribeRouteTablesInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeRouteTablesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeRouteTablesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeRouteTablesInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeRouteTablesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeRouteTablesInput, ...func(*serviceec2.Options)) *serviceec2.DescribeRouteTablesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeRouteTablesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeRouteTablesInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeRouteTables is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeRouteTablesInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeRouteTables(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeRouteTables_Call {
	return &MockClient_DescribeRouteTables_Call{Call: _e.mock.On("DescribeRouteTables",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeRouteTables_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeRouteTablesInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeRouteTables_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeRouteTablesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeRouteTables_Call) Return(_a0 *serviceec2.DescribeRouteTablesOutput, _a1 error) *MockClient_DescribeRouteTables_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeRouteTables_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeRouteTablesInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeRouteTablesOutput, error)) *MockClient_DescribeRouteTables_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSecurityGroups provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeSecurityGroups(_a0 context.Context, _a1 *serviceec2.DescribeSecurityGroupsInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeSecurityGroupsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeSecurityGroupsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeSecurityGroupsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeSecurityGroupsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeSecurityGroupsInput, ...func(*serviceec2.Options)) *serviceec2.DescribeSecurityGroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeSecurityGroupsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeSecurityGroupsInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeSecurityGroups is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeSecurityGroupsInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeSecurityGroups(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeSecurityGroups_Call {
	return &MockClient_DescribeSecurityGroups_Call{Call: _e.mock.On("DescribeSecurityGroups",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeSecurityGroups_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeSecurityGroupsInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeSecurityGroups_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeSecurityGroupsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeSecurityGroups_Call) Return(_a0 *serviceec2.DescribeSecurityGroupsOutput, _a1 error) *MockClient_DescribeSecurityGroups_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeSecurityGroups_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeSecurityGroupsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeSecurityGroupsOutput, error)) *MockClient_DescribeSecurityGroups_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSnapshots provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeSnapshots(_a0 context.Context, _a1 *serviceec2.DescribeSnapshotsInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeSnapshotsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeSnapshotsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeSnapshotsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeSnapshotsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeSnapshotsInput, ...func(*serviceec2.Options)) *serviceec2.DescribeSnapshotsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeSnapshotsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeSnapshotsInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeSnapshots is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeSnapshotsInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeSnapshots(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeSnapshots_Call {
	return &MockClient_DescribeSnapshots_Call{Call: _e.mock.On("DescribeSnapshots",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeSnapshots_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeSnapshotsInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeSnapshots_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeSnapshotsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeSnapshots_Call) Return(_a0 *serviceec2.DescribeSnapshotsOutput, _a1 error) *MockClient_DescribeSnapshots_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeSnapshots_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeSnapshotsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeSnapshotsOutput, error)) *MockClient_DescribeSnapshots_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeSubnets provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeSubnets(_a0 context.Context, _a1 *serviceec2.DescribeSubnetsInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeSubnetsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeSubnetsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeSubnetsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeSubnetsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeSubnetsInput, ...func(*serviceec2.Options)) *serviceec2.DescribeSubnetsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeSubnetsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeSubnetsInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeSubnets is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeSubnetsInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeSubnets(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeSubnets_Call {
	return &MockClient_DescribeSubnets_Call{Call: _e.mock.On("DescribeSubnets",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeSubnets_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeSubnetsInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeSubnets_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeSubnetsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeSubnets_Call) Return(_a0 *serviceec2.DescribeSubnetsOutput, _a1 error) *MockClient_DescribeSubnets_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeSubnets_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeSubnetsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeSubnetsOutput, error)) *MockClient_DescribeSubnets_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGatewayAttachments provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeTransitGatewayAttachments(_a0 context.Context, _a1 *serviceec2.DescribeTransitGatewayAttachmentsInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeTransitGatewayAttachmentsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeTransitGatewayAttachmentsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeTransitGatewayAttachmentsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeTransitGatewayAttachmentsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeTransitGatewayAttachmentsInput, ...func(*serviceec2.Options)) *serviceec2.DescribeTransitGatewayAttachmentsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeTransitGatewayAttachmentsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeTransitGatewayAttachmentsInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeTransitGatewayAttachments is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeTransitGatewayAttachmentsInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeTransitGatewayAttachments(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeTransitGatewayAttachments_Call {
	return &MockClient_DescribeTransitGatewayAttachments_Call{Call: _e.mock.On("DescribeTransitGatewayAttachments",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeTransitGatewayAttachments_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeTransitGatewayAttachmentsInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeTransitGatewayAttachments_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeTransitGatewayAttachmentsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeTransitGatewayAttachments_Call) Return(_a0 *serviceec2.DescribeTransitGatewayAttachmentsOutput, _a1 error) *MockClient_DescribeTransitGatewayAttachments_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeTransitGatewayAttachments_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeTransitGatewayAttachmentsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeTransitGatewayAttachmentsOutput, error)) *MockClient_DescribeTransitGatewayAttachments_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeTransitGateways provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeTransitGateways(_a0 context.Context, _a1 *serviceec2.DescribeTransitGatewaysInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeTransitGatewaysOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeTransitGatewaysOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeTransitGatewaysInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeTransitGatewaysOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeTransitGatewaysInput, ...func(*serviceec2.Options)) *serviceec2.DescribeTransitGatewaysOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeTransitGatewaysOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeTransitGatewaysInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeTransitGateways is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeTransitGatewaysInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeTransitGateways(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeTransitGateways_Call {
	return &MockClient_DescribeTransitGateways_Call{Call: _e.mock.On("DescribeTransitGateways",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeTransitGateways_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeTransitGatewaysInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeTransitGateways_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeTransitGatewaysInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeTransitGateways_Call) Return(_a0 *serviceec2.DescribeTransitGatewaysOutput, _a1 error) *MockClient_DescribeTransitGateways_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeTransitGateways_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeTransitGatewaysInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeTransitGatewaysOutput, error)) *MockClient_DescribeTransitGateways_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVolumes provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeVolumes(_a0 context.Context, _a1 *serviceec2.DescribeVolumesInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeVolumesOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeVolumesOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeVolumesInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeVolumesOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeVolumesInput, ...func(*serviceec2.Options)) *serviceec2.DescribeVolumesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeVolumesOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeVolumesInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeVolumes is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeVolumesInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeVolumes(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeVolumes_Call {
	return &MockClient_DescribeVolumes_Call{Call: _e.mock.On("DescribeVolumes",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeVolumes_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeVolumesInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeVolumes_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeVolumesInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeVolumes_Call) Return(_a0 *serviceec2.DescribeVolumesOutput, _a1 error) *MockClient_DescribeVolumes_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeVolumes_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeVolumesInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeVolumesOutput, error)) *MockClient_DescribeVolumes_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcPeeringConnections provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeVpcPeeringConnections(_a0 context.Context, _a1 *serviceec2.DescribeVpcPeeringConnectionsInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeVpcPeeringConnectionsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeVpcPeeringConnectionsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeVpcPeeringConnectionsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeVpcPeeringConnectionsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeVpcPeeringConnectionsInput, ...func(*serviceec2.Options)) *serviceec2.DescribeVpcPeeringConnectionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeVpcPeeringConnectionsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeVpcPeeringConnectionsInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeVpcPeeringConnections is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeVpcPeeringConnectionsInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeVpcPeeringConnections(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeVpcPeeringConnections_Call {
	return &MockClient_DescribeVpcPeeringConnections_Call{Call: _e.mock.On("DescribeVpcPeeringConnections",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeVpcPeeringConnections_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeVpcPeeringConnectionsInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeVpcPeeringConnections_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeVpcPeeringConnectionsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeVpcPeeringConnections_Call) Return(_a0 *serviceec2.DescribeVpcPeeringConnectionsOutput, _a1 error) *MockClient_DescribeVpcPeeringConnections_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeVpcPeeringConnections_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeVpcPeeringConnectionsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeVpcPeeringConnectionsOutput, error)) *MockClient_DescribeVpcPeeringConnections_Call {
	_c.Call.Return(run)
	return _c
}

// DescribeVpcs provides a mock function with given fields: _a0, _a1, _a2
func (_m *MockClient) DescribeVpcs(_a0 context.Context, _a1 *serviceec2.DescribeVpcsInput, _a2 ...func(*serviceec2.Options)) (*serviceec2.DescribeVpcsOutput, error) {
	_va := make([]interface{}, len(_a2))
	for _i := range _a2 {
		_va[_i] = _a2[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

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

	var r0 *serviceec2.DescribeVpcsOutput
	var r1 error
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeVpcsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeVpcsOutput, error)); ok {
		return rf(_a0, _a1, _a2...)
	}
	if rf, ok := ret.Get(0).(func(context.Context, *serviceec2.DescribeVpcsInput, ...func(*serviceec2.Options)) *serviceec2.DescribeVpcsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*serviceec2.DescribeVpcsOutput)
		}
	}

	if rf, ok := ret.Get(1).(func(context.Context, *serviceec2.DescribeVpcsInput, ...func(*serviceec2.Options)) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

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

// DescribeVpcs is a helper method to define mock.On call
//   - _a0 context.Context
//   - _a1 *serviceec2.DescribeVpcsInput
//   - _a2 ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) DescribeVpcs(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockClient_DescribeVpcs_Call {
	return &MockClient_DescribeVpcs_Call{Call: _e.mock.On("DescribeVpcs",
		append([]interface{}{_a0, _a1}, _a2...)...)}
}

func (_c *MockClient_DescribeVpcs_Call) Run(run func(_a0 context.Context, _a1 *serviceec2.DescribeVpcsInput, _a2 ...func(*serviceec2.Options))) *MockClient_DescribeVpcs_Call {
	_c.Call.Run(func(args mock.Arguments) {
		variadicArgs := make([]func(*serviceec2.Options), len(args)-2)
		for i, a := range args[2:] {
			if a != nil {
				variadicArgs[i] = a.(func(*serviceec2.Options))
			}
		}
		run(args[0].(context.Context), args[1].(*serviceec2.DescribeVpcsInput), variadicArgs...)
	})
	return _c
}

func (_c *MockClient_DescribeVpcs_Call) Return(_a0 *serviceec2.DescribeVpcsOutput, _a1 error) *MockClient_DescribeVpcs_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_DescribeVpcs_Call) RunAndReturn(run func(context.Context, *serviceec2.DescribeVpcsInput, ...func(*serviceec2.Options)) (*serviceec2.DescribeVpcsOutput, error)) *MockClient_DescribeVpcs_Call {
	_c.Call.Return(run)
	return _c
}

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

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

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

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

	return r0, r1
}

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

// GetEbsEncryptionByDefault is a helper method to define mock.On call
//   - ctx context.Context
//   - params *serviceec2.GetEbsEncryptionByDefaultInput
//   - optFns ...func(*serviceec2.Options)
func (_e *MockClient_Expecter) GetEbsEncryptionByDefault(ctx interface{}, params interface{}, optFns ...interface{}) *MockClient_GetEbsEncryptionByDefault_Call {
	return &MockClient_GetEbsEncryptionByDefault_Call{Call: _e.mock.On("GetEbsEncryptionByDefault",
		append([]interface{}{ctx, params}, optFns...)...)}
}

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

func (_c *MockClient_GetEbsEncryptionByDefault_Call) Return(_a0 *serviceec2.GetEbsEncryptionByDefaultOutput, _a1 error) *MockClient_GetEbsEncryptionByDefault_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *MockClient_GetEbsEncryptionByDefault_Call) RunAndReturn(run func(context.Context, *serviceec2.GetEbsEncryptionByDefaultInput, ...func(*serviceec2.Options)) (*serviceec2.GetEbsEncryptionByDefaultOutput, error)) *MockClient_GetEbsEncryptionByDefault_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockClient creates a new instance of MockClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClient {
	mock := &MockClient{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}