// Code generated by mockery v1.0.0. DO NOT EDIT.

package mocks

import (
	context "context"

	eks "github.com/aws/aws-sdk-go/service/eks"

	mock "github.com/stretchr/testify/mock"

	request "github.com/aws/aws-sdk-go/aws/request"
)

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

// AssociateEncryptionConfig provides a mock function with given fields: _a0
func (_m *EKSAPI) AssociateEncryptionConfig(_a0 *eks.AssociateEncryptionConfigInput) (*eks.AssociateEncryptionConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.AssociateEncryptionConfigOutput
	if rf, ok := ret.Get(0).(func(*eks.AssociateEncryptionConfigInput) *eks.AssociateEncryptionConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.AssociateEncryptionConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.AssociateEncryptionConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AssociateEncryptionConfigRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) AssociateEncryptionConfigRequest(_a0 *eks.AssociateEncryptionConfigInput) (*request.Request, *eks.AssociateEncryptionConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.AssociateEncryptionConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.AssociateEncryptionConfigOutput
	if rf, ok := ret.Get(1).(func(*eks.AssociateEncryptionConfigInput) *eks.AssociateEncryptionConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.AssociateEncryptionConfigOutput)
		}
	}

	return r0, r1
}

// AssociateEncryptionConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) AssociateEncryptionConfigWithContext(_a0 context.Context, _a1 *eks.AssociateEncryptionConfigInput, _a2 ...request.Option) (*eks.AssociateEncryptionConfigOutput, 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...)

	var r0 *eks.AssociateEncryptionConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.AssociateEncryptionConfigInput, ...request.Option) *eks.AssociateEncryptionConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.AssociateEncryptionConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.AssociateEncryptionConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AssociateIdentityProviderConfig provides a mock function with given fields: _a0
func (_m *EKSAPI) AssociateIdentityProviderConfig(_a0 *eks.AssociateIdentityProviderConfigInput) (*eks.AssociateIdentityProviderConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.AssociateIdentityProviderConfigOutput
	if rf, ok := ret.Get(0).(func(*eks.AssociateIdentityProviderConfigInput) *eks.AssociateIdentityProviderConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.AssociateIdentityProviderConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.AssociateIdentityProviderConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// AssociateIdentityProviderConfigRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) AssociateIdentityProviderConfigRequest(_a0 *eks.AssociateIdentityProviderConfigInput) (*request.Request, *eks.AssociateIdentityProviderConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.AssociateIdentityProviderConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.AssociateIdentityProviderConfigOutput
	if rf, ok := ret.Get(1).(func(*eks.AssociateIdentityProviderConfigInput) *eks.AssociateIdentityProviderConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.AssociateIdentityProviderConfigOutput)
		}
	}

	return r0, r1
}

// AssociateIdentityProviderConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) AssociateIdentityProviderConfigWithContext(_a0 context.Context, _a1 *eks.AssociateIdentityProviderConfigInput, _a2 ...request.Option) (*eks.AssociateIdentityProviderConfigOutput, 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...)

	var r0 *eks.AssociateIdentityProviderConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.AssociateIdentityProviderConfigInput, ...request.Option) *eks.AssociateIdentityProviderConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.AssociateIdentityProviderConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.AssociateIdentityProviderConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAddon provides a mock function with given fields: _a0
func (_m *EKSAPI) CreateAddon(_a0 *eks.CreateAddonInput) (*eks.CreateAddonOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.CreateAddonOutput
	if rf, ok := ret.Get(0).(func(*eks.CreateAddonInput) *eks.CreateAddonOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.CreateAddonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.CreateAddonInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateAddonRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) CreateAddonRequest(_a0 *eks.CreateAddonInput) (*request.Request, *eks.CreateAddonOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.CreateAddonInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.CreateAddonOutput
	if rf, ok := ret.Get(1).(func(*eks.CreateAddonInput) *eks.CreateAddonOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.CreateAddonOutput)
		}
	}

	return r0, r1
}

// CreateAddonWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) CreateAddonWithContext(_a0 context.Context, _a1 *eks.CreateAddonInput, _a2 ...request.Option) (*eks.CreateAddonOutput, 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...)

	var r0 *eks.CreateAddonOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.CreateAddonInput, ...request.Option) *eks.CreateAddonOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.CreateAddonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.CreateAddonInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateCluster provides a mock function with given fields: _a0
func (_m *EKSAPI) CreateCluster(_a0 *eks.CreateClusterInput) (*eks.CreateClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.CreateClusterOutput
	if rf, ok := ret.Get(0).(func(*eks.CreateClusterInput) *eks.CreateClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.CreateClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.CreateClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateClusterRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) CreateClusterRequest(_a0 *eks.CreateClusterInput) (*request.Request, *eks.CreateClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.CreateClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.CreateClusterOutput
	if rf, ok := ret.Get(1).(func(*eks.CreateClusterInput) *eks.CreateClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.CreateClusterOutput)
		}
	}

	return r0, r1
}

// CreateClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) CreateClusterWithContext(_a0 context.Context, _a1 *eks.CreateClusterInput, _a2 ...request.Option) (*eks.CreateClusterOutput, 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...)

	var r0 *eks.CreateClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.CreateClusterInput, ...request.Option) *eks.CreateClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.CreateClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.CreateClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFargateProfile provides a mock function with given fields: _a0
func (_m *EKSAPI) CreateFargateProfile(_a0 *eks.CreateFargateProfileInput) (*eks.CreateFargateProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.CreateFargateProfileOutput
	if rf, ok := ret.Get(0).(func(*eks.CreateFargateProfileInput) *eks.CreateFargateProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.CreateFargateProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.CreateFargateProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateFargateProfileRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) CreateFargateProfileRequest(_a0 *eks.CreateFargateProfileInput) (*request.Request, *eks.CreateFargateProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.CreateFargateProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.CreateFargateProfileOutput
	if rf, ok := ret.Get(1).(func(*eks.CreateFargateProfileInput) *eks.CreateFargateProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.CreateFargateProfileOutput)
		}
	}

	return r0, r1
}

// CreateFargateProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) CreateFargateProfileWithContext(_a0 context.Context, _a1 *eks.CreateFargateProfileInput, _a2 ...request.Option) (*eks.CreateFargateProfileOutput, 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...)

	var r0 *eks.CreateFargateProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.CreateFargateProfileInput, ...request.Option) *eks.CreateFargateProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.CreateFargateProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.CreateFargateProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateNodegroup provides a mock function with given fields: _a0
func (_m *EKSAPI) CreateNodegroup(_a0 *eks.CreateNodegroupInput) (*eks.CreateNodegroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.CreateNodegroupOutput
	if rf, ok := ret.Get(0).(func(*eks.CreateNodegroupInput) *eks.CreateNodegroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.CreateNodegroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.CreateNodegroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CreateNodegroupRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) CreateNodegroupRequest(_a0 *eks.CreateNodegroupInput) (*request.Request, *eks.CreateNodegroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.CreateNodegroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.CreateNodegroupOutput
	if rf, ok := ret.Get(1).(func(*eks.CreateNodegroupInput) *eks.CreateNodegroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.CreateNodegroupOutput)
		}
	}

	return r0, r1
}

// CreateNodegroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) CreateNodegroupWithContext(_a0 context.Context, _a1 *eks.CreateNodegroupInput, _a2 ...request.Option) (*eks.CreateNodegroupOutput, 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...)

	var r0 *eks.CreateNodegroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.CreateNodegroupInput, ...request.Option) *eks.CreateNodegroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.CreateNodegroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.CreateNodegroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAddon provides a mock function with given fields: _a0
func (_m *EKSAPI) DeleteAddon(_a0 *eks.DeleteAddonInput) (*eks.DeleteAddonOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DeleteAddonOutput
	if rf, ok := ret.Get(0).(func(*eks.DeleteAddonInput) *eks.DeleteAddonOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeleteAddonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DeleteAddonInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAddonRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DeleteAddonRequest(_a0 *eks.DeleteAddonInput) (*request.Request, *eks.DeleteAddonOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DeleteAddonInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DeleteAddonOutput
	if rf, ok := ret.Get(1).(func(*eks.DeleteAddonInput) *eks.DeleteAddonOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DeleteAddonOutput)
		}
	}

	return r0, r1
}

// DeleteAddonWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DeleteAddonWithContext(_a0 context.Context, _a1 *eks.DeleteAddonInput, _a2 ...request.Option) (*eks.DeleteAddonOutput, 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...)

	var r0 *eks.DeleteAddonOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DeleteAddonInput, ...request.Option) *eks.DeleteAddonOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeleteAddonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DeleteAddonInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteCluster provides a mock function with given fields: _a0
func (_m *EKSAPI) DeleteCluster(_a0 *eks.DeleteClusterInput) (*eks.DeleteClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DeleteClusterOutput
	if rf, ok := ret.Get(0).(func(*eks.DeleteClusterInput) *eks.DeleteClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeleteClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DeleteClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteClusterRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DeleteClusterRequest(_a0 *eks.DeleteClusterInput) (*request.Request, *eks.DeleteClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DeleteClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DeleteClusterOutput
	if rf, ok := ret.Get(1).(func(*eks.DeleteClusterInput) *eks.DeleteClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DeleteClusterOutput)
		}
	}

	return r0, r1
}

// DeleteClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DeleteClusterWithContext(_a0 context.Context, _a1 *eks.DeleteClusterInput, _a2 ...request.Option) (*eks.DeleteClusterOutput, 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...)

	var r0 *eks.DeleteClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DeleteClusterInput, ...request.Option) *eks.DeleteClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeleteClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DeleteClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFargateProfile provides a mock function with given fields: _a0
func (_m *EKSAPI) DeleteFargateProfile(_a0 *eks.DeleteFargateProfileInput) (*eks.DeleteFargateProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DeleteFargateProfileOutput
	if rf, ok := ret.Get(0).(func(*eks.DeleteFargateProfileInput) *eks.DeleteFargateProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeleteFargateProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DeleteFargateProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteFargateProfileRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DeleteFargateProfileRequest(_a0 *eks.DeleteFargateProfileInput) (*request.Request, *eks.DeleteFargateProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DeleteFargateProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DeleteFargateProfileOutput
	if rf, ok := ret.Get(1).(func(*eks.DeleteFargateProfileInput) *eks.DeleteFargateProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DeleteFargateProfileOutput)
		}
	}

	return r0, r1
}

// DeleteFargateProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DeleteFargateProfileWithContext(_a0 context.Context, _a1 *eks.DeleteFargateProfileInput, _a2 ...request.Option) (*eks.DeleteFargateProfileOutput, 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...)

	var r0 *eks.DeleteFargateProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DeleteFargateProfileInput, ...request.Option) *eks.DeleteFargateProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeleteFargateProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DeleteFargateProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteNodegroup provides a mock function with given fields: _a0
func (_m *EKSAPI) DeleteNodegroup(_a0 *eks.DeleteNodegroupInput) (*eks.DeleteNodegroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DeleteNodegroupOutput
	if rf, ok := ret.Get(0).(func(*eks.DeleteNodegroupInput) *eks.DeleteNodegroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeleteNodegroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DeleteNodegroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteNodegroupRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DeleteNodegroupRequest(_a0 *eks.DeleteNodegroupInput) (*request.Request, *eks.DeleteNodegroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DeleteNodegroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DeleteNodegroupOutput
	if rf, ok := ret.Get(1).(func(*eks.DeleteNodegroupInput) *eks.DeleteNodegroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DeleteNodegroupOutput)
		}
	}

	return r0, r1
}

// DeleteNodegroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DeleteNodegroupWithContext(_a0 context.Context, _a1 *eks.DeleteNodegroupInput, _a2 ...request.Option) (*eks.DeleteNodegroupOutput, 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...)

	var r0 *eks.DeleteNodegroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DeleteNodegroupInput, ...request.Option) *eks.DeleteNodegroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeleteNodegroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DeleteNodegroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterCluster provides a mock function with given fields: _a0
func (_m *EKSAPI) DeregisterCluster(_a0 *eks.DeregisterClusterInput) (*eks.DeregisterClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DeregisterClusterOutput
	if rf, ok := ret.Get(0).(func(*eks.DeregisterClusterInput) *eks.DeregisterClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeregisterClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DeregisterClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeregisterClusterRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DeregisterClusterRequest(_a0 *eks.DeregisterClusterInput) (*request.Request, *eks.DeregisterClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DeregisterClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DeregisterClusterOutput
	if rf, ok := ret.Get(1).(func(*eks.DeregisterClusterInput) *eks.DeregisterClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DeregisterClusterOutput)
		}
	}

	return r0, r1
}

// DeregisterClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DeregisterClusterWithContext(_a0 context.Context, _a1 *eks.DeregisterClusterInput, _a2 ...request.Option) (*eks.DeregisterClusterOutput, 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...)

	var r0 *eks.DeregisterClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DeregisterClusterInput, ...request.Option) *eks.DeregisterClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DeregisterClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DeregisterClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAddon provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeAddon(_a0 *eks.DescribeAddonInput) (*eks.DescribeAddonOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DescribeAddonOutput
	if rf, ok := ret.Get(0).(func(*eks.DescribeAddonInput) *eks.DescribeAddonOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeAddonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DescribeAddonInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAddonRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeAddonRequest(_a0 *eks.DescribeAddonInput) (*request.Request, *eks.DescribeAddonOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DescribeAddonInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DescribeAddonOutput
	if rf, ok := ret.Get(1).(func(*eks.DescribeAddonInput) *eks.DescribeAddonOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DescribeAddonOutput)
		}
	}

	return r0, r1
}

// DescribeAddonVersions provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeAddonVersions(_a0 *eks.DescribeAddonVersionsInput) (*eks.DescribeAddonVersionsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DescribeAddonVersionsOutput
	if rf, ok := ret.Get(0).(func(*eks.DescribeAddonVersionsInput) *eks.DescribeAddonVersionsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeAddonVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DescribeAddonVersionsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAddonVersionsPages provides a mock function with given fields: _a0, _a1
func (_m *EKSAPI) DescribeAddonVersionsPages(_a0 *eks.DescribeAddonVersionsInput, _a1 func(*eks.DescribeAddonVersionsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeAddonVersionsInput, func(*eks.DescribeAddonVersionsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeAddonVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *EKSAPI) DescribeAddonVersionsPagesWithContext(_a0 context.Context, _a1 *eks.DescribeAddonVersionsInput, _a2 func(*eks.DescribeAddonVersionsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeAddonVersionsInput, func(*eks.DescribeAddonVersionsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DescribeAddonVersionsRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeAddonVersionsRequest(_a0 *eks.DescribeAddonVersionsInput) (*request.Request, *eks.DescribeAddonVersionsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DescribeAddonVersionsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DescribeAddonVersionsOutput
	if rf, ok := ret.Get(1).(func(*eks.DescribeAddonVersionsInput) *eks.DescribeAddonVersionsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DescribeAddonVersionsOutput)
		}
	}

	return r0, r1
}

// DescribeAddonVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DescribeAddonVersionsWithContext(_a0 context.Context, _a1 *eks.DescribeAddonVersionsInput, _a2 ...request.Option) (*eks.DescribeAddonVersionsOutput, 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...)

	var r0 *eks.DescribeAddonVersionsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeAddonVersionsInput, ...request.Option) *eks.DescribeAddonVersionsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeAddonVersionsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DescribeAddonVersionsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeAddonWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DescribeAddonWithContext(_a0 context.Context, _a1 *eks.DescribeAddonInput, _a2 ...request.Option) (*eks.DescribeAddonOutput, 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...)

	var r0 *eks.DescribeAddonOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeAddonInput, ...request.Option) *eks.DescribeAddonOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeAddonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DescribeAddonInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeCluster provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeCluster(_a0 *eks.DescribeClusterInput) (*eks.DescribeClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DescribeClusterOutput
	if rf, ok := ret.Get(0).(func(*eks.DescribeClusterInput) *eks.DescribeClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DescribeClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeClusterRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeClusterRequest(_a0 *eks.DescribeClusterInput) (*request.Request, *eks.DescribeClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DescribeClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DescribeClusterOutput
	if rf, ok := ret.Get(1).(func(*eks.DescribeClusterInput) *eks.DescribeClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DescribeClusterOutput)
		}
	}

	return r0, r1
}

// DescribeClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DescribeClusterWithContext(_a0 context.Context, _a1 *eks.DescribeClusterInput, _a2 ...request.Option) (*eks.DescribeClusterOutput, 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...)

	var r0 *eks.DescribeClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeClusterInput, ...request.Option) *eks.DescribeClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DescribeClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeFargateProfile provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeFargateProfile(_a0 *eks.DescribeFargateProfileInput) (*eks.DescribeFargateProfileOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DescribeFargateProfileOutput
	if rf, ok := ret.Get(0).(func(*eks.DescribeFargateProfileInput) *eks.DescribeFargateProfileOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeFargateProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DescribeFargateProfileInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeFargateProfileRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeFargateProfileRequest(_a0 *eks.DescribeFargateProfileInput) (*request.Request, *eks.DescribeFargateProfileOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DescribeFargateProfileInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DescribeFargateProfileOutput
	if rf, ok := ret.Get(1).(func(*eks.DescribeFargateProfileInput) *eks.DescribeFargateProfileOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DescribeFargateProfileOutput)
		}
	}

	return r0, r1
}

// DescribeFargateProfileWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DescribeFargateProfileWithContext(_a0 context.Context, _a1 *eks.DescribeFargateProfileInput, _a2 ...request.Option) (*eks.DescribeFargateProfileOutput, 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...)

	var r0 *eks.DescribeFargateProfileOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeFargateProfileInput, ...request.Option) *eks.DescribeFargateProfileOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeFargateProfileOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DescribeFargateProfileInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeIdentityProviderConfig provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeIdentityProviderConfig(_a0 *eks.DescribeIdentityProviderConfigInput) (*eks.DescribeIdentityProviderConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DescribeIdentityProviderConfigOutput
	if rf, ok := ret.Get(0).(func(*eks.DescribeIdentityProviderConfigInput) *eks.DescribeIdentityProviderConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeIdentityProviderConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DescribeIdentityProviderConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeIdentityProviderConfigRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeIdentityProviderConfigRequest(_a0 *eks.DescribeIdentityProviderConfigInput) (*request.Request, *eks.DescribeIdentityProviderConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DescribeIdentityProviderConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DescribeIdentityProviderConfigOutput
	if rf, ok := ret.Get(1).(func(*eks.DescribeIdentityProviderConfigInput) *eks.DescribeIdentityProviderConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DescribeIdentityProviderConfigOutput)
		}
	}

	return r0, r1
}

// DescribeIdentityProviderConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DescribeIdentityProviderConfigWithContext(_a0 context.Context, _a1 *eks.DescribeIdentityProviderConfigInput, _a2 ...request.Option) (*eks.DescribeIdentityProviderConfigOutput, 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...)

	var r0 *eks.DescribeIdentityProviderConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeIdentityProviderConfigInput, ...request.Option) *eks.DescribeIdentityProviderConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeIdentityProviderConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DescribeIdentityProviderConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeNodegroup provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeNodegroup(_a0 *eks.DescribeNodegroupInput) (*eks.DescribeNodegroupOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DescribeNodegroupOutput
	if rf, ok := ret.Get(0).(func(*eks.DescribeNodegroupInput) *eks.DescribeNodegroupOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeNodegroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DescribeNodegroupInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeNodegroupRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeNodegroupRequest(_a0 *eks.DescribeNodegroupInput) (*request.Request, *eks.DescribeNodegroupOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DescribeNodegroupInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DescribeNodegroupOutput
	if rf, ok := ret.Get(1).(func(*eks.DescribeNodegroupInput) *eks.DescribeNodegroupOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DescribeNodegroupOutput)
		}
	}

	return r0, r1
}

// DescribeNodegroupWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DescribeNodegroupWithContext(_a0 context.Context, _a1 *eks.DescribeNodegroupInput, _a2 ...request.Option) (*eks.DescribeNodegroupOutput, 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...)

	var r0 *eks.DescribeNodegroupOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeNodegroupInput, ...request.Option) *eks.DescribeNodegroupOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeNodegroupOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DescribeNodegroupInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeUpdate provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeUpdate(_a0 *eks.DescribeUpdateInput) (*eks.DescribeUpdateOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DescribeUpdateOutput
	if rf, ok := ret.Get(0).(func(*eks.DescribeUpdateInput) *eks.DescribeUpdateOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeUpdateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DescribeUpdateInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DescribeUpdateRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DescribeUpdateRequest(_a0 *eks.DescribeUpdateInput) (*request.Request, *eks.DescribeUpdateOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DescribeUpdateInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DescribeUpdateOutput
	if rf, ok := ret.Get(1).(func(*eks.DescribeUpdateInput) *eks.DescribeUpdateOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DescribeUpdateOutput)
		}
	}

	return r0, r1
}

// DescribeUpdateWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DescribeUpdateWithContext(_a0 context.Context, _a1 *eks.DescribeUpdateInput, _a2 ...request.Option) (*eks.DescribeUpdateOutput, 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...)

	var r0 *eks.DescribeUpdateOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeUpdateInput, ...request.Option) *eks.DescribeUpdateOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DescribeUpdateOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DescribeUpdateInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateIdentityProviderConfig provides a mock function with given fields: _a0
func (_m *EKSAPI) DisassociateIdentityProviderConfig(_a0 *eks.DisassociateIdentityProviderConfigInput) (*eks.DisassociateIdentityProviderConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.DisassociateIdentityProviderConfigOutput
	if rf, ok := ret.Get(0).(func(*eks.DisassociateIdentityProviderConfigInput) *eks.DisassociateIdentityProviderConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DisassociateIdentityProviderConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.DisassociateIdentityProviderConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DisassociateIdentityProviderConfigRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) DisassociateIdentityProviderConfigRequest(_a0 *eks.DisassociateIdentityProviderConfigInput) (*request.Request, *eks.DisassociateIdentityProviderConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.DisassociateIdentityProviderConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.DisassociateIdentityProviderConfigOutput
	if rf, ok := ret.Get(1).(func(*eks.DisassociateIdentityProviderConfigInput) *eks.DisassociateIdentityProviderConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.DisassociateIdentityProviderConfigOutput)
		}
	}

	return r0, r1
}

// DisassociateIdentityProviderConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) DisassociateIdentityProviderConfigWithContext(_a0 context.Context, _a1 *eks.DisassociateIdentityProviderConfigInput, _a2 ...request.Option) (*eks.DisassociateIdentityProviderConfigOutput, 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...)

	var r0 *eks.DisassociateIdentityProviderConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DisassociateIdentityProviderConfigInput, ...request.Option) *eks.DisassociateIdentityProviderConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.DisassociateIdentityProviderConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.DisassociateIdentityProviderConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAddons provides a mock function with given fields: _a0
func (_m *EKSAPI) ListAddons(_a0 *eks.ListAddonsInput) (*eks.ListAddonsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.ListAddonsOutput
	if rf, ok := ret.Get(0).(func(*eks.ListAddonsInput) *eks.ListAddonsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListAddonsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.ListAddonsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListAddonsPages provides a mock function with given fields: _a0, _a1
func (_m *EKSAPI) ListAddonsPages(_a0 *eks.ListAddonsInput, _a1 func(*eks.ListAddonsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.ListAddonsInput, func(*eks.ListAddonsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAddonsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *EKSAPI) ListAddonsPagesWithContext(_a0 context.Context, _a1 *eks.ListAddonsInput, _a2 func(*eks.ListAddonsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListAddonsInput, func(*eks.ListAddonsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListAddonsRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) ListAddonsRequest(_a0 *eks.ListAddonsInput) (*request.Request, *eks.ListAddonsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.ListAddonsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.ListAddonsOutput
	if rf, ok := ret.Get(1).(func(*eks.ListAddonsInput) *eks.ListAddonsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.ListAddonsOutput)
		}
	}

	return r0, r1
}

// ListAddonsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) ListAddonsWithContext(_a0 context.Context, _a1 *eks.ListAddonsInput, _a2 ...request.Option) (*eks.ListAddonsOutput, 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...)

	var r0 *eks.ListAddonsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListAddonsInput, ...request.Option) *eks.ListAddonsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListAddonsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.ListAddonsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListClusters provides a mock function with given fields: _a0
func (_m *EKSAPI) ListClusters(_a0 *eks.ListClustersInput) (*eks.ListClustersOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.ListClustersOutput
	if rf, ok := ret.Get(0).(func(*eks.ListClustersInput) *eks.ListClustersOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.ListClustersInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListClustersPages provides a mock function with given fields: _a0, _a1
func (_m *EKSAPI) ListClustersPages(_a0 *eks.ListClustersInput, _a1 func(*eks.ListClustersOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.ListClustersInput, func(*eks.ListClustersOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListClustersPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *EKSAPI) ListClustersPagesWithContext(_a0 context.Context, _a1 *eks.ListClustersInput, _a2 func(*eks.ListClustersOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListClustersInput, func(*eks.ListClustersOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListClustersRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) ListClustersRequest(_a0 *eks.ListClustersInput) (*request.Request, *eks.ListClustersOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.ListClustersInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.ListClustersOutput
	if rf, ok := ret.Get(1).(func(*eks.ListClustersInput) *eks.ListClustersOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.ListClustersOutput)
		}
	}

	return r0, r1
}

// ListClustersWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) ListClustersWithContext(_a0 context.Context, _a1 *eks.ListClustersInput, _a2 ...request.Option) (*eks.ListClustersOutput, 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...)

	var r0 *eks.ListClustersOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListClustersInput, ...request.Option) *eks.ListClustersOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListClustersOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.ListClustersInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFargateProfiles provides a mock function with given fields: _a0
func (_m *EKSAPI) ListFargateProfiles(_a0 *eks.ListFargateProfilesInput) (*eks.ListFargateProfilesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.ListFargateProfilesOutput
	if rf, ok := ret.Get(0).(func(*eks.ListFargateProfilesInput) *eks.ListFargateProfilesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListFargateProfilesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.ListFargateProfilesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListFargateProfilesPages provides a mock function with given fields: _a0, _a1
func (_m *EKSAPI) ListFargateProfilesPages(_a0 *eks.ListFargateProfilesInput, _a1 func(*eks.ListFargateProfilesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.ListFargateProfilesInput, func(*eks.ListFargateProfilesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFargateProfilesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *EKSAPI) ListFargateProfilesPagesWithContext(_a0 context.Context, _a1 *eks.ListFargateProfilesInput, _a2 func(*eks.ListFargateProfilesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListFargateProfilesInput, func(*eks.ListFargateProfilesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListFargateProfilesRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) ListFargateProfilesRequest(_a0 *eks.ListFargateProfilesInput) (*request.Request, *eks.ListFargateProfilesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.ListFargateProfilesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.ListFargateProfilesOutput
	if rf, ok := ret.Get(1).(func(*eks.ListFargateProfilesInput) *eks.ListFargateProfilesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.ListFargateProfilesOutput)
		}
	}

	return r0, r1
}

// ListFargateProfilesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) ListFargateProfilesWithContext(_a0 context.Context, _a1 *eks.ListFargateProfilesInput, _a2 ...request.Option) (*eks.ListFargateProfilesOutput, 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...)

	var r0 *eks.ListFargateProfilesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListFargateProfilesInput, ...request.Option) *eks.ListFargateProfilesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListFargateProfilesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.ListFargateProfilesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListIdentityProviderConfigs provides a mock function with given fields: _a0
func (_m *EKSAPI) ListIdentityProviderConfigs(_a0 *eks.ListIdentityProviderConfigsInput) (*eks.ListIdentityProviderConfigsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.ListIdentityProviderConfigsOutput
	if rf, ok := ret.Get(0).(func(*eks.ListIdentityProviderConfigsInput) *eks.ListIdentityProviderConfigsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListIdentityProviderConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.ListIdentityProviderConfigsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListIdentityProviderConfigsPages provides a mock function with given fields: _a0, _a1
func (_m *EKSAPI) ListIdentityProviderConfigsPages(_a0 *eks.ListIdentityProviderConfigsInput, _a1 func(*eks.ListIdentityProviderConfigsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.ListIdentityProviderConfigsInput, func(*eks.ListIdentityProviderConfigsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListIdentityProviderConfigsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *EKSAPI) ListIdentityProviderConfigsPagesWithContext(_a0 context.Context, _a1 *eks.ListIdentityProviderConfigsInput, _a2 func(*eks.ListIdentityProviderConfigsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListIdentityProviderConfigsInput, func(*eks.ListIdentityProviderConfigsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListIdentityProviderConfigsRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) ListIdentityProviderConfigsRequest(_a0 *eks.ListIdentityProviderConfigsInput) (*request.Request, *eks.ListIdentityProviderConfigsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.ListIdentityProviderConfigsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.ListIdentityProviderConfigsOutput
	if rf, ok := ret.Get(1).(func(*eks.ListIdentityProviderConfigsInput) *eks.ListIdentityProviderConfigsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.ListIdentityProviderConfigsOutput)
		}
	}

	return r0, r1
}

// ListIdentityProviderConfigsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) ListIdentityProviderConfigsWithContext(_a0 context.Context, _a1 *eks.ListIdentityProviderConfigsInput, _a2 ...request.Option) (*eks.ListIdentityProviderConfigsOutput, 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...)

	var r0 *eks.ListIdentityProviderConfigsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListIdentityProviderConfigsInput, ...request.Option) *eks.ListIdentityProviderConfigsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListIdentityProviderConfigsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.ListIdentityProviderConfigsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListNodegroups provides a mock function with given fields: _a0
func (_m *EKSAPI) ListNodegroups(_a0 *eks.ListNodegroupsInput) (*eks.ListNodegroupsOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.ListNodegroupsOutput
	if rf, ok := ret.Get(0).(func(*eks.ListNodegroupsInput) *eks.ListNodegroupsOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListNodegroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.ListNodegroupsInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListNodegroupsPages provides a mock function with given fields: _a0, _a1
func (_m *EKSAPI) ListNodegroupsPages(_a0 *eks.ListNodegroupsInput, _a1 func(*eks.ListNodegroupsOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.ListNodegroupsInput, func(*eks.ListNodegroupsOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListNodegroupsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *EKSAPI) ListNodegroupsPagesWithContext(_a0 context.Context, _a1 *eks.ListNodegroupsInput, _a2 func(*eks.ListNodegroupsOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListNodegroupsInput, func(*eks.ListNodegroupsOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListNodegroupsRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) ListNodegroupsRequest(_a0 *eks.ListNodegroupsInput) (*request.Request, *eks.ListNodegroupsOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.ListNodegroupsInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.ListNodegroupsOutput
	if rf, ok := ret.Get(1).(func(*eks.ListNodegroupsInput) *eks.ListNodegroupsOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.ListNodegroupsOutput)
		}
	}

	return r0, r1
}

// ListNodegroupsWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) ListNodegroupsWithContext(_a0 context.Context, _a1 *eks.ListNodegroupsInput, _a2 ...request.Option) (*eks.ListNodegroupsOutput, 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...)

	var r0 *eks.ListNodegroupsOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListNodegroupsInput, ...request.Option) *eks.ListNodegroupsOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListNodegroupsOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.ListNodegroupsInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResource provides a mock function with given fields: _a0
func (_m *EKSAPI) ListTagsForResource(_a0 *eks.ListTagsForResourceInput) (*eks.ListTagsForResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(*eks.ListTagsForResourceInput) *eks.ListTagsForResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.ListTagsForResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListTagsForResourceRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) ListTagsForResourceRequest(_a0 *eks.ListTagsForResourceInput) (*request.Request, *eks.ListTagsForResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.ListTagsForResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.ListTagsForResourceOutput
	if rf, ok := ret.Get(1).(func(*eks.ListTagsForResourceInput) *eks.ListTagsForResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.ListTagsForResourceOutput)
		}
	}

	return r0, r1
}

// ListTagsForResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) ListTagsForResourceWithContext(_a0 context.Context, _a1 *eks.ListTagsForResourceInput, _a2 ...request.Option) (*eks.ListTagsForResourceOutput, 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...)

	var r0 *eks.ListTagsForResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListTagsForResourceInput, ...request.Option) *eks.ListTagsForResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListTagsForResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.ListTagsForResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUpdates provides a mock function with given fields: _a0
func (_m *EKSAPI) ListUpdates(_a0 *eks.ListUpdatesInput) (*eks.ListUpdatesOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.ListUpdatesOutput
	if rf, ok := ret.Get(0).(func(*eks.ListUpdatesInput) *eks.ListUpdatesOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListUpdatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.ListUpdatesInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListUpdatesPages provides a mock function with given fields: _a0, _a1
func (_m *EKSAPI) ListUpdatesPages(_a0 *eks.ListUpdatesInput, _a1 func(*eks.ListUpdatesOutput, bool) bool) error {
	ret := _m.Called(_a0, _a1)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.ListUpdatesInput, func(*eks.ListUpdatesOutput, bool) bool) error); ok {
		r0 = rf(_a0, _a1)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListUpdatesPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3
func (_m *EKSAPI) ListUpdatesPagesWithContext(_a0 context.Context, _a1 *eks.ListUpdatesInput, _a2 func(*eks.ListUpdatesOutput, bool) bool, _a3 ...request.Option) error {
	_va := make([]interface{}, len(_a3))
	for _i := range _a3 {
		_va[_i] = _a3[_i]
	}
	var _ca []interface{}
	_ca = append(_ca, _a0, _a1, _a2)
	_ca = append(_ca, _va...)
	ret := _m.Called(_ca...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListUpdatesInput, func(*eks.ListUpdatesOutput, bool) bool, ...request.Option) error); ok {
		r0 = rf(_a0, _a1, _a2, _a3...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// ListUpdatesRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) ListUpdatesRequest(_a0 *eks.ListUpdatesInput) (*request.Request, *eks.ListUpdatesOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.ListUpdatesInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.ListUpdatesOutput
	if rf, ok := ret.Get(1).(func(*eks.ListUpdatesInput) *eks.ListUpdatesOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.ListUpdatesOutput)
		}
	}

	return r0, r1
}

// ListUpdatesWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) ListUpdatesWithContext(_a0 context.Context, _a1 *eks.ListUpdatesInput, _a2 ...request.Option) (*eks.ListUpdatesOutput, 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...)

	var r0 *eks.ListUpdatesOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.ListUpdatesInput, ...request.Option) *eks.ListUpdatesOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.ListUpdatesOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.ListUpdatesInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterCluster provides a mock function with given fields: _a0
func (_m *EKSAPI) RegisterCluster(_a0 *eks.RegisterClusterInput) (*eks.RegisterClusterOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.RegisterClusterOutput
	if rf, ok := ret.Get(0).(func(*eks.RegisterClusterInput) *eks.RegisterClusterOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.RegisterClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.RegisterClusterInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// RegisterClusterRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) RegisterClusterRequest(_a0 *eks.RegisterClusterInput) (*request.Request, *eks.RegisterClusterOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.RegisterClusterInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.RegisterClusterOutput
	if rf, ok := ret.Get(1).(func(*eks.RegisterClusterInput) *eks.RegisterClusterOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.RegisterClusterOutput)
		}
	}

	return r0, r1
}

// RegisterClusterWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) RegisterClusterWithContext(_a0 context.Context, _a1 *eks.RegisterClusterInput, _a2 ...request.Option) (*eks.RegisterClusterOutput, 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...)

	var r0 *eks.RegisterClusterOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.RegisterClusterInput, ...request.Option) *eks.RegisterClusterOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.RegisterClusterOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.RegisterClusterInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagResource provides a mock function with given fields: _a0
func (_m *EKSAPI) TagResource(_a0 *eks.TagResourceInput) (*eks.TagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.TagResourceOutput
	if rf, ok := ret.Get(0).(func(*eks.TagResourceInput) *eks.TagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.TagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.TagResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// TagResourceRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) TagResourceRequest(_a0 *eks.TagResourceInput) (*request.Request, *eks.TagResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.TagResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.TagResourceOutput
	if rf, ok := ret.Get(1).(func(*eks.TagResourceInput) *eks.TagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.TagResourceOutput)
		}
	}

	return r0, r1
}

// TagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) TagResourceWithContext(_a0 context.Context, _a1 *eks.TagResourceInput, _a2 ...request.Option) (*eks.TagResourceOutput, 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...)

	var r0 *eks.TagResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.TagResourceInput, ...request.Option) *eks.TagResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.TagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.TagResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagResource provides a mock function with given fields: _a0
func (_m *EKSAPI) UntagResource(_a0 *eks.UntagResourceInput) (*eks.UntagResourceOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(*eks.UntagResourceInput) *eks.UntagResourceOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UntagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.UntagResourceInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UntagResourceRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) UntagResourceRequest(_a0 *eks.UntagResourceInput) (*request.Request, *eks.UntagResourceOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.UntagResourceInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.UntagResourceOutput
	if rf, ok := ret.Get(1).(func(*eks.UntagResourceInput) *eks.UntagResourceOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.UntagResourceOutput)
		}
	}

	return r0, r1
}

// UntagResourceWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) UntagResourceWithContext(_a0 context.Context, _a1 *eks.UntagResourceInput, _a2 ...request.Option) (*eks.UntagResourceOutput, 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...)

	var r0 *eks.UntagResourceOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.UntagResourceInput, ...request.Option) *eks.UntagResourceOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UntagResourceOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.UntagResourceInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAddon provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateAddon(_a0 *eks.UpdateAddonInput) (*eks.UpdateAddonOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.UpdateAddonOutput
	if rf, ok := ret.Get(0).(func(*eks.UpdateAddonInput) *eks.UpdateAddonOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateAddonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.UpdateAddonInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateAddonRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateAddonRequest(_a0 *eks.UpdateAddonInput) (*request.Request, *eks.UpdateAddonOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.UpdateAddonInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.UpdateAddonOutput
	if rf, ok := ret.Get(1).(func(*eks.UpdateAddonInput) *eks.UpdateAddonOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.UpdateAddonOutput)
		}
	}

	return r0, r1
}

// UpdateAddonWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) UpdateAddonWithContext(_a0 context.Context, _a1 *eks.UpdateAddonInput, _a2 ...request.Option) (*eks.UpdateAddonOutput, 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...)

	var r0 *eks.UpdateAddonOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.UpdateAddonInput, ...request.Option) *eks.UpdateAddonOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateAddonOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.UpdateAddonInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateClusterConfig provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateClusterConfig(_a0 *eks.UpdateClusterConfigInput) (*eks.UpdateClusterConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.UpdateClusterConfigOutput
	if rf, ok := ret.Get(0).(func(*eks.UpdateClusterConfigInput) *eks.UpdateClusterConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateClusterConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.UpdateClusterConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateClusterConfigRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateClusterConfigRequest(_a0 *eks.UpdateClusterConfigInput) (*request.Request, *eks.UpdateClusterConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.UpdateClusterConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.UpdateClusterConfigOutput
	if rf, ok := ret.Get(1).(func(*eks.UpdateClusterConfigInput) *eks.UpdateClusterConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.UpdateClusterConfigOutput)
		}
	}

	return r0, r1
}

// UpdateClusterConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) UpdateClusterConfigWithContext(_a0 context.Context, _a1 *eks.UpdateClusterConfigInput, _a2 ...request.Option) (*eks.UpdateClusterConfigOutput, 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...)

	var r0 *eks.UpdateClusterConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.UpdateClusterConfigInput, ...request.Option) *eks.UpdateClusterConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateClusterConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.UpdateClusterConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateClusterVersion provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateClusterVersion(_a0 *eks.UpdateClusterVersionInput) (*eks.UpdateClusterVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.UpdateClusterVersionOutput
	if rf, ok := ret.Get(0).(func(*eks.UpdateClusterVersionInput) *eks.UpdateClusterVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateClusterVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.UpdateClusterVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateClusterVersionRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateClusterVersionRequest(_a0 *eks.UpdateClusterVersionInput) (*request.Request, *eks.UpdateClusterVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.UpdateClusterVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.UpdateClusterVersionOutput
	if rf, ok := ret.Get(1).(func(*eks.UpdateClusterVersionInput) *eks.UpdateClusterVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.UpdateClusterVersionOutput)
		}
	}

	return r0, r1
}

// UpdateClusterVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) UpdateClusterVersionWithContext(_a0 context.Context, _a1 *eks.UpdateClusterVersionInput, _a2 ...request.Option) (*eks.UpdateClusterVersionOutput, 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...)

	var r0 *eks.UpdateClusterVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.UpdateClusterVersionInput, ...request.Option) *eks.UpdateClusterVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateClusterVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.UpdateClusterVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateNodegroupConfig provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateNodegroupConfig(_a0 *eks.UpdateNodegroupConfigInput) (*eks.UpdateNodegroupConfigOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.UpdateNodegroupConfigOutput
	if rf, ok := ret.Get(0).(func(*eks.UpdateNodegroupConfigInput) *eks.UpdateNodegroupConfigOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateNodegroupConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.UpdateNodegroupConfigInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateNodegroupConfigRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateNodegroupConfigRequest(_a0 *eks.UpdateNodegroupConfigInput) (*request.Request, *eks.UpdateNodegroupConfigOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.UpdateNodegroupConfigInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.UpdateNodegroupConfigOutput
	if rf, ok := ret.Get(1).(func(*eks.UpdateNodegroupConfigInput) *eks.UpdateNodegroupConfigOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.UpdateNodegroupConfigOutput)
		}
	}

	return r0, r1
}

// UpdateNodegroupConfigWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) UpdateNodegroupConfigWithContext(_a0 context.Context, _a1 *eks.UpdateNodegroupConfigInput, _a2 ...request.Option) (*eks.UpdateNodegroupConfigOutput, 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...)

	var r0 *eks.UpdateNodegroupConfigOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.UpdateNodegroupConfigInput, ...request.Option) *eks.UpdateNodegroupConfigOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateNodegroupConfigOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.UpdateNodegroupConfigInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateNodegroupVersion provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateNodegroupVersion(_a0 *eks.UpdateNodegroupVersionInput) (*eks.UpdateNodegroupVersionOutput, error) {
	ret := _m.Called(_a0)

	var r0 *eks.UpdateNodegroupVersionOutput
	if rf, ok := ret.Get(0).(func(*eks.UpdateNodegroupVersionInput) *eks.UpdateNodegroupVersionOutput); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateNodegroupVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(*eks.UpdateNodegroupVersionInput) error); ok {
		r1 = rf(_a0)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateNodegroupVersionRequest provides a mock function with given fields: _a0
func (_m *EKSAPI) UpdateNodegroupVersionRequest(_a0 *eks.UpdateNodegroupVersionInput) (*request.Request, *eks.UpdateNodegroupVersionOutput) {
	ret := _m.Called(_a0)

	var r0 *request.Request
	if rf, ok := ret.Get(0).(func(*eks.UpdateNodegroupVersionInput) *request.Request); ok {
		r0 = rf(_a0)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*request.Request)
		}
	}

	var r1 *eks.UpdateNodegroupVersionOutput
	if rf, ok := ret.Get(1).(func(*eks.UpdateNodegroupVersionInput) *eks.UpdateNodegroupVersionOutput); ok {
		r1 = rf(_a0)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*eks.UpdateNodegroupVersionOutput)
		}
	}

	return r0, r1
}

// UpdateNodegroupVersionWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) UpdateNodegroupVersionWithContext(_a0 context.Context, _a1 *eks.UpdateNodegroupVersionInput, _a2 ...request.Option) (*eks.UpdateNodegroupVersionOutput, 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...)

	var r0 *eks.UpdateNodegroupVersionOutput
	if rf, ok := ret.Get(0).(func(context.Context, *eks.UpdateNodegroupVersionInput, ...request.Option) *eks.UpdateNodegroupVersionOutput); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*eks.UpdateNodegroupVersionOutput)
		}
	}

	var r1 error
	if rf, ok := ret.Get(1).(func(context.Context, *eks.UpdateNodegroupVersionInput, ...request.Option) error); ok {
		r1 = rf(_a0, _a1, _a2...)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// WaitUntilAddonActive provides a mock function with given fields: _a0
func (_m *EKSAPI) WaitUntilAddonActive(_a0 *eks.DescribeAddonInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeAddonInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilAddonActiveWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) WaitUntilAddonActiveWithContext(_a0 context.Context, _a1 *eks.DescribeAddonInput, _a2 ...request.WaiterOption) 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...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeAddonInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilAddonDeleted provides a mock function with given fields: _a0
func (_m *EKSAPI) WaitUntilAddonDeleted(_a0 *eks.DescribeAddonInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeAddonInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilAddonDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) WaitUntilAddonDeletedWithContext(_a0 context.Context, _a1 *eks.DescribeAddonInput, _a2 ...request.WaiterOption) 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...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeAddonInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilClusterActive provides a mock function with given fields: _a0
func (_m *EKSAPI) WaitUntilClusterActive(_a0 *eks.DescribeClusterInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeClusterInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilClusterActiveWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) WaitUntilClusterActiveWithContext(_a0 context.Context, _a1 *eks.DescribeClusterInput, _a2 ...request.WaiterOption) 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...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeClusterInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilClusterDeleted provides a mock function with given fields: _a0
func (_m *EKSAPI) WaitUntilClusterDeleted(_a0 *eks.DescribeClusterInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeClusterInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilClusterDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) WaitUntilClusterDeletedWithContext(_a0 context.Context, _a1 *eks.DescribeClusterInput, _a2 ...request.WaiterOption) 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...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeClusterInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFargateProfileActive provides a mock function with given fields: _a0
func (_m *EKSAPI) WaitUntilFargateProfileActive(_a0 *eks.DescribeFargateProfileInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeFargateProfileInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFargateProfileActiveWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) WaitUntilFargateProfileActiveWithContext(_a0 context.Context, _a1 *eks.DescribeFargateProfileInput, _a2 ...request.WaiterOption) 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...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeFargateProfileInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFargateProfileDeleted provides a mock function with given fields: _a0
func (_m *EKSAPI) WaitUntilFargateProfileDeleted(_a0 *eks.DescribeFargateProfileInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeFargateProfileInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilFargateProfileDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) WaitUntilFargateProfileDeletedWithContext(_a0 context.Context, _a1 *eks.DescribeFargateProfileInput, _a2 ...request.WaiterOption) 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...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeFargateProfileInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNodegroupActive provides a mock function with given fields: _a0
func (_m *EKSAPI) WaitUntilNodegroupActive(_a0 *eks.DescribeNodegroupInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeNodegroupInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNodegroupActiveWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) WaitUntilNodegroupActiveWithContext(_a0 context.Context, _a1 *eks.DescribeNodegroupInput, _a2 ...request.WaiterOption) 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...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeNodegroupInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNodegroupDeleted provides a mock function with given fields: _a0
func (_m *EKSAPI) WaitUntilNodegroupDeleted(_a0 *eks.DescribeNodegroupInput) error {
	ret := _m.Called(_a0)

	var r0 error
	if rf, ok := ret.Get(0).(func(*eks.DescribeNodegroupInput) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// WaitUntilNodegroupDeletedWithContext provides a mock function with given fields: _a0, _a1, _a2
func (_m *EKSAPI) WaitUntilNodegroupDeletedWithContext(_a0 context.Context, _a1 *eks.DescribeNodegroupInput, _a2 ...request.WaiterOption) 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...)

	var r0 error
	if rf, ok := ret.Get(0).(func(context.Context, *eks.DescribeNodegroupInput, ...request.WaiterOption) error); ok {
		r0 = rf(_a0, _a1, _a2...)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
