// Code generated by MockGen. DO NOT EDIT.
// Source: ./pkg/aws/services/eks.go

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

import (
	reflect "reflect"

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

// MockEKS is a mock of EKS interface.
type MockEKS struct {
	ctrl     *gomock.Controller
	recorder *MockEKSMockRecorder
}

// MockEKSMockRecorder is the mock recorder for MockEKS.
type MockEKSMockRecorder struct {
	mock *MockEKS
}

// NewMockEKS creates a new mock instance.
func NewMockEKS(ctrl *gomock.Controller) *MockEKS {
	mock := &MockEKS{ctrl: ctrl}
	mock.recorder = &MockEKSMockRecorder{mock}
	return mock
}

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

// AssociateEncryptionConfig mocks base method.
func (m *MockEKS) AssociateEncryptionConfig(arg0 *eks.AssociateEncryptionConfigInput) (*eks.AssociateEncryptionConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateEncryptionConfig", arg0)
	ret0, _ := ret[0].(*eks.AssociateEncryptionConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateEncryptionConfigRequest mocks base method.
func (m *MockEKS) AssociateEncryptionConfigRequest(arg0 *eks.AssociateEncryptionConfigInput) (*request.Request, *eks.AssociateEncryptionConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateEncryptionConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.AssociateEncryptionConfigOutput)
	return ret0, ret1
}

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

// AssociateEncryptionConfigWithContext mocks base method.
func (m *MockEKS) AssociateEncryptionConfigWithContext(arg0 aws.Context, arg1 *eks.AssociateEncryptionConfigInput, arg2 ...request.Option) (*eks.AssociateEncryptionConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateEncryptionConfigWithContext", varargs...)
	ret0, _ := ret[0].(*eks.AssociateEncryptionConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateIdentityProviderConfig mocks base method.
func (m *MockEKS) AssociateIdentityProviderConfig(arg0 *eks.AssociateIdentityProviderConfigInput) (*eks.AssociateIdentityProviderConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateIdentityProviderConfig", arg0)
	ret0, _ := ret[0].(*eks.AssociateIdentityProviderConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// AssociateIdentityProviderConfigRequest mocks base method.
func (m *MockEKS) AssociateIdentityProviderConfigRequest(arg0 *eks.AssociateIdentityProviderConfigInput) (*request.Request, *eks.AssociateIdentityProviderConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssociateIdentityProviderConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.AssociateIdentityProviderConfigOutput)
	return ret0, ret1
}

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

// AssociateIdentityProviderConfigWithContext mocks base method.
func (m *MockEKS) AssociateIdentityProviderConfigWithContext(arg0 aws.Context, arg1 *eks.AssociateIdentityProviderConfigInput, arg2 ...request.Option) (*eks.AssociateIdentityProviderConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AssociateIdentityProviderConfigWithContext", varargs...)
	ret0, _ := ret[0].(*eks.AssociateIdentityProviderConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAddon mocks base method.
func (m *MockEKS) CreateAddon(arg0 *eks.CreateAddonInput) (*eks.CreateAddonOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAddon", arg0)
	ret0, _ := ret[0].(*eks.CreateAddonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateAddonRequest mocks base method.
func (m *MockEKS) CreateAddonRequest(arg0 *eks.CreateAddonInput) (*request.Request, *eks.CreateAddonOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateAddonRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.CreateAddonOutput)
	return ret0, ret1
}

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

// CreateAddonWithContext mocks base method.
func (m *MockEKS) CreateAddonWithContext(arg0 aws.Context, arg1 *eks.CreateAddonInput, arg2 ...request.Option) (*eks.CreateAddonOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateAddonWithContext", varargs...)
	ret0, _ := ret[0].(*eks.CreateAddonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateCluster mocks base method.
func (m *MockEKS) CreateCluster(arg0 *eks.CreateClusterInput) (*eks.CreateClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateCluster", arg0)
	ret0, _ := ret[0].(*eks.CreateClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateClusterRequest mocks base method.
func (m *MockEKS) CreateClusterRequest(arg0 *eks.CreateClusterInput) (*request.Request, *eks.CreateClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.CreateClusterOutput)
	return ret0, ret1
}

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

// CreateClusterWithContext mocks base method.
func (m *MockEKS) CreateClusterWithContext(arg0 aws.Context, arg1 *eks.CreateClusterInput, arg2 ...request.Option) (*eks.CreateClusterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateClusterWithContext", varargs...)
	ret0, _ := ret[0].(*eks.CreateClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFargateProfile mocks base method.
func (m *MockEKS) CreateFargateProfile(arg0 *eks.CreateFargateProfileInput) (*eks.CreateFargateProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFargateProfile", arg0)
	ret0, _ := ret[0].(*eks.CreateFargateProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFargateProfileRequest mocks base method.
func (m *MockEKS) CreateFargateProfileRequest(arg0 *eks.CreateFargateProfileInput) (*request.Request, *eks.CreateFargateProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateFargateProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.CreateFargateProfileOutput)
	return ret0, ret1
}

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

// CreateFargateProfileWithContext mocks base method.
func (m *MockEKS) CreateFargateProfileWithContext(arg0 aws.Context, arg1 *eks.CreateFargateProfileInput, arg2 ...request.Option) (*eks.CreateFargateProfileOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFargateProfileWithContext", varargs...)
	ret0, _ := ret[0].(*eks.CreateFargateProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNodegroup mocks base method.
func (m *MockEKS) CreateNodegroup(arg0 *eks.CreateNodegroupInput) (*eks.CreateNodegroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodegroup", arg0)
	ret0, _ := ret[0].(*eks.CreateNodegroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateNodegroupRequest mocks base method.
func (m *MockEKS) CreateNodegroupRequest(arg0 *eks.CreateNodegroupInput) (*request.Request, *eks.CreateNodegroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNodegroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.CreateNodegroupOutput)
	return ret0, ret1
}

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

// CreateNodegroupWithContext mocks base method.
func (m *MockEKS) CreateNodegroupWithContext(arg0 aws.Context, arg1 *eks.CreateNodegroupInput, arg2 ...request.Option) (*eks.CreateNodegroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNodegroupWithContext", varargs...)
	ret0, _ := ret[0].(*eks.CreateNodegroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAddon mocks base method.
func (m *MockEKS) DeleteAddon(arg0 *eks.DeleteAddonInput) (*eks.DeleteAddonOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAddon", arg0)
	ret0, _ := ret[0].(*eks.DeleteAddonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteAddonRequest mocks base method.
func (m *MockEKS) DeleteAddonRequest(arg0 *eks.DeleteAddonInput) (*request.Request, *eks.DeleteAddonOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteAddonRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DeleteAddonOutput)
	return ret0, ret1
}

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

// DeleteAddonWithContext mocks base method.
func (m *MockEKS) DeleteAddonWithContext(arg0 aws.Context, arg1 *eks.DeleteAddonInput, arg2 ...request.Option) (*eks.DeleteAddonOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteAddonWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DeleteAddonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteCluster mocks base method.
func (m *MockEKS) DeleteCluster(arg0 *eks.DeleteClusterInput) (*eks.DeleteClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCluster", arg0)
	ret0, _ := ret[0].(*eks.DeleteClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteClusterRequest mocks base method.
func (m *MockEKS) DeleteClusterRequest(arg0 *eks.DeleteClusterInput) (*request.Request, *eks.DeleteClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DeleteClusterOutput)
	return ret0, ret1
}

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

// DeleteClusterWithContext mocks base method.
func (m *MockEKS) DeleteClusterWithContext(arg0 aws.Context, arg1 *eks.DeleteClusterInput, arg2 ...request.Option) (*eks.DeleteClusterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteClusterWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DeleteClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFargateProfile mocks base method.
func (m *MockEKS) DeleteFargateProfile(arg0 *eks.DeleteFargateProfileInput) (*eks.DeleteFargateProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFargateProfile", arg0)
	ret0, _ := ret[0].(*eks.DeleteFargateProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteFargateProfileRequest mocks base method.
func (m *MockEKS) DeleteFargateProfileRequest(arg0 *eks.DeleteFargateProfileInput) (*request.Request, *eks.DeleteFargateProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteFargateProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DeleteFargateProfileOutput)
	return ret0, ret1
}

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

// DeleteFargateProfileWithContext mocks base method.
func (m *MockEKS) DeleteFargateProfileWithContext(arg0 aws.Context, arg1 *eks.DeleteFargateProfileInput, arg2 ...request.Option) (*eks.DeleteFargateProfileOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteFargateProfileWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DeleteFargateProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNodegroup mocks base method.
func (m *MockEKS) DeleteNodegroup(arg0 *eks.DeleteNodegroupInput) (*eks.DeleteNodegroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNodegroup", arg0)
	ret0, _ := ret[0].(*eks.DeleteNodegroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeleteNodegroupRequest mocks base method.
func (m *MockEKS) DeleteNodegroupRequest(arg0 *eks.DeleteNodegroupInput) (*request.Request, *eks.DeleteNodegroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNodegroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DeleteNodegroupOutput)
	return ret0, ret1
}

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

// DeleteNodegroupWithContext mocks base method.
func (m *MockEKS) DeleteNodegroupWithContext(arg0 aws.Context, arg1 *eks.DeleteNodegroupInput, arg2 ...request.Option) (*eks.DeleteNodegroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteNodegroupWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DeleteNodegroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterCluster mocks base method.
func (m *MockEKS) DeregisterCluster(arg0 *eks.DeregisterClusterInput) (*eks.DeregisterClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterCluster", arg0)
	ret0, _ := ret[0].(*eks.DeregisterClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DeregisterClusterRequest mocks base method.
func (m *MockEKS) DeregisterClusterRequest(arg0 *eks.DeregisterClusterInput) (*request.Request, *eks.DeregisterClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeregisterClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DeregisterClusterOutput)
	return ret0, ret1
}

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

// DeregisterClusterWithContext mocks base method.
func (m *MockEKS) DeregisterClusterWithContext(arg0 aws.Context, arg1 *eks.DeregisterClusterInput, arg2 ...request.Option) (*eks.DeregisterClusterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeregisterClusterWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DeregisterClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddon mocks base method.
func (m *MockEKS) DescribeAddon(arg0 *eks.DescribeAddonInput) (*eks.DescribeAddonOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddon", arg0)
	ret0, _ := ret[0].(*eks.DescribeAddonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddonConfiguration mocks base method.
func (m *MockEKS) DescribeAddonConfiguration(arg0 *eks.DescribeAddonConfigurationInput) (*eks.DescribeAddonConfigurationOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddonConfiguration", arg0)
	ret0, _ := ret[0].(*eks.DescribeAddonConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddonConfigurationRequest mocks base method.
func (m *MockEKS) DescribeAddonConfigurationRequest(arg0 *eks.DescribeAddonConfigurationInput) (*request.Request, *eks.DescribeAddonConfigurationOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddonConfigurationRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DescribeAddonConfigurationOutput)
	return ret0, ret1
}

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

// DescribeAddonConfigurationWithContext mocks base method.
func (m *MockEKS) DescribeAddonConfigurationWithContext(arg0 aws.Context, arg1 *eks.DescribeAddonConfigurationInput, arg2 ...request.Option) (*eks.DescribeAddonConfigurationOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddonConfigurationWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DescribeAddonConfigurationOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddonRequest mocks base method.
func (m *MockEKS) DescribeAddonRequest(arg0 *eks.DescribeAddonInput) (*request.Request, *eks.DescribeAddonOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddonRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DescribeAddonOutput)
	return ret0, ret1
}

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

// DescribeAddonVersions mocks base method.
func (m *MockEKS) DescribeAddonVersions(arg0 *eks.DescribeAddonVersionsInput) (*eks.DescribeAddonVersionsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddonVersions", arg0)
	ret0, _ := ret[0].(*eks.DescribeAddonVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddonVersionsPages mocks base method.
func (m *MockEKS) DescribeAddonVersionsPages(arg0 *eks.DescribeAddonVersionsInput, arg1 func(*eks.DescribeAddonVersionsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddonVersionsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeAddonVersionsPagesWithContext mocks base method.
func (m *MockEKS) DescribeAddonVersionsPagesWithContext(arg0 aws.Context, arg1 *eks.DescribeAddonVersionsInput, arg2 func(*eks.DescribeAddonVersionsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddonVersionsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// DescribeAddonVersionsRequest mocks base method.
func (m *MockEKS) DescribeAddonVersionsRequest(arg0 *eks.DescribeAddonVersionsInput) (*request.Request, *eks.DescribeAddonVersionsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeAddonVersionsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DescribeAddonVersionsOutput)
	return ret0, ret1
}

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

// DescribeAddonVersionsWithContext mocks base method.
func (m *MockEKS) DescribeAddonVersionsWithContext(arg0 aws.Context, arg1 *eks.DescribeAddonVersionsInput, arg2 ...request.Option) (*eks.DescribeAddonVersionsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddonVersionsWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DescribeAddonVersionsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeAddonWithContext mocks base method.
func (m *MockEKS) DescribeAddonWithContext(arg0 aws.Context, arg1 *eks.DescribeAddonInput, arg2 ...request.Option) (*eks.DescribeAddonOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeAddonWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DescribeAddonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeCluster mocks base method.
func (m *MockEKS) DescribeCluster(arg0 *eks.DescribeClusterInput) (*eks.DescribeClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeCluster", arg0)
	ret0, _ := ret[0].(*eks.DescribeClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeClusterRequest mocks base method.
func (m *MockEKS) DescribeClusterRequest(arg0 *eks.DescribeClusterInput) (*request.Request, *eks.DescribeClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DescribeClusterOutput)
	return ret0, ret1
}

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

// DescribeClusterWithContext mocks base method.
func (m *MockEKS) DescribeClusterWithContext(arg0 aws.Context, arg1 *eks.DescribeClusterInput, arg2 ...request.Option) (*eks.DescribeClusterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeClusterWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DescribeClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFargateProfile mocks base method.
func (m *MockEKS) DescribeFargateProfile(arg0 *eks.DescribeFargateProfileInput) (*eks.DescribeFargateProfileOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFargateProfile", arg0)
	ret0, _ := ret[0].(*eks.DescribeFargateProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeFargateProfileRequest mocks base method.
func (m *MockEKS) DescribeFargateProfileRequest(arg0 *eks.DescribeFargateProfileInput) (*request.Request, *eks.DescribeFargateProfileOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeFargateProfileRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DescribeFargateProfileOutput)
	return ret0, ret1
}

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

// DescribeFargateProfileWithContext mocks base method.
func (m *MockEKS) DescribeFargateProfileWithContext(arg0 aws.Context, arg1 *eks.DescribeFargateProfileInput, arg2 ...request.Option) (*eks.DescribeFargateProfileOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeFargateProfileWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DescribeFargateProfileOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIdentityProviderConfig mocks base method.
func (m *MockEKS) DescribeIdentityProviderConfig(arg0 *eks.DescribeIdentityProviderConfigInput) (*eks.DescribeIdentityProviderConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIdentityProviderConfig", arg0)
	ret0, _ := ret[0].(*eks.DescribeIdentityProviderConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeIdentityProviderConfigRequest mocks base method.
func (m *MockEKS) DescribeIdentityProviderConfigRequest(arg0 *eks.DescribeIdentityProviderConfigInput) (*request.Request, *eks.DescribeIdentityProviderConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeIdentityProviderConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DescribeIdentityProviderConfigOutput)
	return ret0, ret1
}

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

// DescribeIdentityProviderConfigWithContext mocks base method.
func (m *MockEKS) DescribeIdentityProviderConfigWithContext(arg0 aws.Context, arg1 *eks.DescribeIdentityProviderConfigInput, arg2 ...request.Option) (*eks.DescribeIdentityProviderConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeIdentityProviderConfigWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DescribeIdentityProviderConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNodegroup mocks base method.
func (m *MockEKS) DescribeNodegroup(arg0 *eks.DescribeNodegroupInput) (*eks.DescribeNodegroupOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNodegroup", arg0)
	ret0, _ := ret[0].(*eks.DescribeNodegroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeNodegroupRequest mocks base method.
func (m *MockEKS) DescribeNodegroupRequest(arg0 *eks.DescribeNodegroupInput) (*request.Request, *eks.DescribeNodegroupOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeNodegroupRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DescribeNodegroupOutput)
	return ret0, ret1
}

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

// DescribeNodegroupWithContext mocks base method.
func (m *MockEKS) DescribeNodegroupWithContext(arg0 aws.Context, arg1 *eks.DescribeNodegroupInput, arg2 ...request.Option) (*eks.DescribeNodegroupOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeNodegroupWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DescribeNodegroupOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeUpdate mocks base method.
func (m *MockEKS) DescribeUpdate(arg0 *eks.DescribeUpdateInput) (*eks.DescribeUpdateOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeUpdate", arg0)
	ret0, _ := ret[0].(*eks.DescribeUpdateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DescribeUpdateRequest mocks base method.
func (m *MockEKS) DescribeUpdateRequest(arg0 *eks.DescribeUpdateInput) (*request.Request, *eks.DescribeUpdateOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DescribeUpdateRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DescribeUpdateOutput)
	return ret0, ret1
}

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

// DescribeUpdateWithContext mocks base method.
func (m *MockEKS) DescribeUpdateWithContext(arg0 aws.Context, arg1 *eks.DescribeUpdateInput, arg2 ...request.Option) (*eks.DescribeUpdateOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DescribeUpdateWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DescribeUpdateOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateIdentityProviderConfig mocks base method.
func (m *MockEKS) DisassociateIdentityProviderConfig(arg0 *eks.DisassociateIdentityProviderConfigInput) (*eks.DisassociateIdentityProviderConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateIdentityProviderConfig", arg0)
	ret0, _ := ret[0].(*eks.DisassociateIdentityProviderConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisassociateIdentityProviderConfigRequest mocks base method.
func (m *MockEKS) DisassociateIdentityProviderConfigRequest(arg0 *eks.DisassociateIdentityProviderConfigInput) (*request.Request, *eks.DisassociateIdentityProviderConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisassociateIdentityProviderConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.DisassociateIdentityProviderConfigOutput)
	return ret0, ret1
}

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

// DisassociateIdentityProviderConfigWithContext mocks base method.
func (m *MockEKS) DisassociateIdentityProviderConfigWithContext(arg0 aws.Context, arg1 *eks.DisassociateIdentityProviderConfigInput, arg2 ...request.Option) (*eks.DisassociateIdentityProviderConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DisassociateIdentityProviderConfigWithContext", varargs...)
	ret0, _ := ret[0].(*eks.DisassociateIdentityProviderConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAddons mocks base method.
func (m *MockEKS) ListAddons(arg0 *eks.ListAddonsInput) (*eks.ListAddonsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAddons", arg0)
	ret0, _ := ret[0].(*eks.ListAddonsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListAddonsPages mocks base method.
func (m *MockEKS) ListAddonsPages(arg0 *eks.ListAddonsInput, arg1 func(*eks.ListAddonsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAddonsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAddonsPagesWithContext mocks base method.
func (m *MockEKS) ListAddonsPagesWithContext(arg0 aws.Context, arg1 *eks.ListAddonsInput, arg2 func(*eks.ListAddonsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAddonsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListAddonsRequest mocks base method.
func (m *MockEKS) ListAddonsRequest(arg0 *eks.ListAddonsInput) (*request.Request, *eks.ListAddonsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListAddonsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.ListAddonsOutput)
	return ret0, ret1
}

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

// ListAddonsWithContext mocks base method.
func (m *MockEKS) ListAddonsWithContext(arg0 aws.Context, arg1 *eks.ListAddonsInput, arg2 ...request.Option) (*eks.ListAddonsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListAddonsWithContext", varargs...)
	ret0, _ := ret[0].(*eks.ListAddonsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListClusters mocks base method.
func (m *MockEKS) ListClusters(arg0 *eks.ListClustersInput) (*eks.ListClustersOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusters", arg0)
	ret0, _ := ret[0].(*eks.ListClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListClustersPages mocks base method.
func (m *MockEKS) ListClustersPages(arg0 *eks.ListClustersInput, arg1 func(*eks.ListClustersOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClustersPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListClustersPagesWithContext mocks base method.
func (m *MockEKS) ListClustersPagesWithContext(arg0 aws.Context, arg1 *eks.ListClustersInput, arg2 func(*eks.ListClustersOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClustersPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListClustersRequest mocks base method.
func (m *MockEKS) ListClustersRequest(arg0 *eks.ListClustersInput) (*request.Request, *eks.ListClustersOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClustersRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.ListClustersOutput)
	return ret0, ret1
}

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

// ListClustersWithContext mocks base method.
func (m *MockEKS) ListClustersWithContext(arg0 aws.Context, arg1 *eks.ListClustersInput, arg2 ...request.Option) (*eks.ListClustersOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListClustersWithContext", varargs...)
	ret0, _ := ret[0].(*eks.ListClustersOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFargateProfiles mocks base method.
func (m *MockEKS) ListFargateProfiles(arg0 *eks.ListFargateProfilesInput) (*eks.ListFargateProfilesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFargateProfiles", arg0)
	ret0, _ := ret[0].(*eks.ListFargateProfilesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListFargateProfilesPages mocks base method.
func (m *MockEKS) ListFargateProfilesPages(arg0 *eks.ListFargateProfilesInput, arg1 func(*eks.ListFargateProfilesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFargateProfilesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListFargateProfilesPagesWithContext mocks base method.
func (m *MockEKS) ListFargateProfilesPagesWithContext(arg0 aws.Context, arg1 *eks.ListFargateProfilesInput, arg2 func(*eks.ListFargateProfilesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFargateProfilesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListFargateProfilesRequest mocks base method.
func (m *MockEKS) ListFargateProfilesRequest(arg0 *eks.ListFargateProfilesInput) (*request.Request, *eks.ListFargateProfilesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListFargateProfilesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.ListFargateProfilesOutput)
	return ret0, ret1
}

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

// ListFargateProfilesWithContext mocks base method.
func (m *MockEKS) ListFargateProfilesWithContext(arg0 aws.Context, arg1 *eks.ListFargateProfilesInput, arg2 ...request.Option) (*eks.ListFargateProfilesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListFargateProfilesWithContext", varargs...)
	ret0, _ := ret[0].(*eks.ListFargateProfilesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIdentityProviderConfigs mocks base method.
func (m *MockEKS) ListIdentityProviderConfigs(arg0 *eks.ListIdentityProviderConfigsInput) (*eks.ListIdentityProviderConfigsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdentityProviderConfigs", arg0)
	ret0, _ := ret[0].(*eks.ListIdentityProviderConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListIdentityProviderConfigsPages mocks base method.
func (m *MockEKS) ListIdentityProviderConfigsPages(arg0 *eks.ListIdentityProviderConfigsInput, arg1 func(*eks.ListIdentityProviderConfigsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdentityProviderConfigsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIdentityProviderConfigsPagesWithContext mocks base method.
func (m *MockEKS) ListIdentityProviderConfigsPagesWithContext(arg0 aws.Context, arg1 *eks.ListIdentityProviderConfigsInput, arg2 func(*eks.ListIdentityProviderConfigsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIdentityProviderConfigsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListIdentityProviderConfigsRequest mocks base method.
func (m *MockEKS) ListIdentityProviderConfigsRequest(arg0 *eks.ListIdentityProviderConfigsInput) (*request.Request, *eks.ListIdentityProviderConfigsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListIdentityProviderConfigsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.ListIdentityProviderConfigsOutput)
	return ret0, ret1
}

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

// ListIdentityProviderConfigsWithContext mocks base method.
func (m *MockEKS) ListIdentityProviderConfigsWithContext(arg0 aws.Context, arg1 *eks.ListIdentityProviderConfigsInput, arg2 ...request.Option) (*eks.ListIdentityProviderConfigsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListIdentityProviderConfigsWithContext", varargs...)
	ret0, _ := ret[0].(*eks.ListIdentityProviderConfigsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNodegroups mocks base method.
func (m *MockEKS) ListNodegroups(arg0 *eks.ListNodegroupsInput) (*eks.ListNodegroupsOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodegroups", arg0)
	ret0, _ := ret[0].(*eks.ListNodegroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListNodegroupsPages mocks base method.
func (m *MockEKS) ListNodegroupsPages(arg0 *eks.ListNodegroupsInput, arg1 func(*eks.ListNodegroupsOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodegroupsPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListNodegroupsPagesWithContext mocks base method.
func (m *MockEKS) ListNodegroupsPagesWithContext(arg0 aws.Context, arg1 *eks.ListNodegroupsInput, arg2 func(*eks.ListNodegroupsOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNodegroupsPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListNodegroupsRequest mocks base method.
func (m *MockEKS) ListNodegroupsRequest(arg0 *eks.ListNodegroupsInput) (*request.Request, *eks.ListNodegroupsOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodegroupsRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.ListNodegroupsOutput)
	return ret0, ret1
}

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

// ListNodegroupsWithContext mocks base method.
func (m *MockEKS) ListNodegroupsWithContext(arg0 aws.Context, arg1 *eks.ListNodegroupsInput, arg2 ...request.Option) (*eks.ListNodegroupsOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListNodegroupsWithContext", varargs...)
	ret0, _ := ret[0].(*eks.ListNodegroupsOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResource mocks base method.
func (m *MockEKS) ListTagsForResource(arg0 *eks.ListTagsForResourceInput) (*eks.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResource", arg0)
	ret0, _ := ret[0].(*eks.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListTagsForResourceRequest mocks base method.
func (m *MockEKS) ListTagsForResourceRequest(arg0 *eks.ListTagsForResourceInput) (*request.Request, *eks.ListTagsForResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListTagsForResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.ListTagsForResourceOutput)
	return ret0, ret1
}

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

// ListTagsForResourceWithContext mocks base method.
func (m *MockEKS) ListTagsForResourceWithContext(arg0 aws.Context, arg1 *eks.ListTagsForResourceInput, arg2 ...request.Option) (*eks.ListTagsForResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListTagsForResourceWithContext", varargs...)
	ret0, _ := ret[0].(*eks.ListTagsForResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUpdates mocks base method.
func (m *MockEKS) ListUpdates(arg0 *eks.ListUpdatesInput) (*eks.ListUpdatesOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUpdates", arg0)
	ret0, _ := ret[0].(*eks.ListUpdatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListUpdatesPages mocks base method.
func (m *MockEKS) ListUpdatesPages(arg0 *eks.ListUpdatesInput, arg1 func(*eks.ListUpdatesOutput, bool) bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUpdatesPages", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListUpdatesPagesWithContext mocks base method.
func (m *MockEKS) ListUpdatesPagesWithContext(arg0 aws.Context, arg1 *eks.ListUpdatesInput, arg2 func(*eks.ListUpdatesOutput, bool) bool, arg3 ...request.Option) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUpdatesPagesWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// ListUpdatesRequest mocks base method.
func (m *MockEKS) ListUpdatesRequest(arg0 *eks.ListUpdatesInput) (*request.Request, *eks.ListUpdatesOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListUpdatesRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.ListUpdatesOutput)
	return ret0, ret1
}

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

// ListUpdatesWithContext mocks base method.
func (m *MockEKS) ListUpdatesWithContext(arg0 aws.Context, arg1 *eks.ListUpdatesInput, arg2 ...request.Option) (*eks.ListUpdatesOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListUpdatesWithContext", varargs...)
	ret0, _ := ret[0].(*eks.ListUpdatesOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterCluster mocks base method.
func (m *MockEKS) RegisterCluster(arg0 *eks.RegisterClusterInput) (*eks.RegisterClusterOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterCluster", arg0)
	ret0, _ := ret[0].(*eks.RegisterClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterClusterRequest mocks base method.
func (m *MockEKS) RegisterClusterRequest(arg0 *eks.RegisterClusterInput) (*request.Request, *eks.RegisterClusterOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterClusterRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.RegisterClusterOutput)
	return ret0, ret1
}

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

// RegisterClusterWithContext mocks base method.
func (m *MockEKS) RegisterClusterWithContext(arg0 aws.Context, arg1 *eks.RegisterClusterInput, arg2 ...request.Option) (*eks.RegisterClusterOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RegisterClusterWithContext", varargs...)
	ret0, _ := ret[0].(*eks.RegisterClusterOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TagResource mocks base method.
func (m *MockEKS) TagResource(arg0 *eks.TagResourceInput) (*eks.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResource", arg0)
	ret0, _ := ret[0].(*eks.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// TagResourceRequest mocks base method.
func (m *MockEKS) TagResourceRequest(arg0 *eks.TagResourceInput) (*request.Request, *eks.TagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.TagResourceOutput)
	return ret0, ret1
}

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

// TagResourceWithContext mocks base method.
func (m *MockEKS) TagResourceWithContext(arg0 aws.Context, arg1 *eks.TagResourceInput, arg2 ...request.Option) (*eks.TagResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "TagResourceWithContext", varargs...)
	ret0, _ := ret[0].(*eks.TagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UntagResource mocks base method.
func (m *MockEKS) UntagResource(arg0 *eks.UntagResourceInput) (*eks.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResource", arg0)
	ret0, _ := ret[0].(*eks.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UntagResourceRequest mocks base method.
func (m *MockEKS) UntagResourceRequest(arg0 *eks.UntagResourceInput) (*request.Request, *eks.UntagResourceOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UntagResourceRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.UntagResourceOutput)
	return ret0, ret1
}

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

// UntagResourceWithContext mocks base method.
func (m *MockEKS) UntagResourceWithContext(arg0 aws.Context, arg1 *eks.UntagResourceInput, arg2 ...request.Option) (*eks.UntagResourceOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UntagResourceWithContext", varargs...)
	ret0, _ := ret[0].(*eks.UntagResourceOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAddon mocks base method.
func (m *MockEKS) UpdateAddon(arg0 *eks.UpdateAddonInput) (*eks.UpdateAddonOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAddon", arg0)
	ret0, _ := ret[0].(*eks.UpdateAddonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateAddonRequest mocks base method.
func (m *MockEKS) UpdateAddonRequest(arg0 *eks.UpdateAddonInput) (*request.Request, *eks.UpdateAddonOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateAddonRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.UpdateAddonOutput)
	return ret0, ret1
}

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

// UpdateAddonWithContext mocks base method.
func (m *MockEKS) UpdateAddonWithContext(arg0 aws.Context, arg1 *eks.UpdateAddonInput, arg2 ...request.Option) (*eks.UpdateAddonOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateAddonWithContext", varargs...)
	ret0, _ := ret[0].(*eks.UpdateAddonOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateClusterConfig mocks base method.
func (m *MockEKS) UpdateClusterConfig(arg0 *eks.UpdateClusterConfigInput) (*eks.UpdateClusterConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterConfig", arg0)
	ret0, _ := ret[0].(*eks.UpdateClusterConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateClusterConfigRequest mocks base method.
func (m *MockEKS) UpdateClusterConfigRequest(arg0 *eks.UpdateClusterConfigInput) (*request.Request, *eks.UpdateClusterConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.UpdateClusterConfigOutput)
	return ret0, ret1
}

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

// UpdateClusterConfigWithContext mocks base method.
func (m *MockEKS) UpdateClusterConfigWithContext(arg0 aws.Context, arg1 *eks.UpdateClusterConfigInput, arg2 ...request.Option) (*eks.UpdateClusterConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateClusterConfigWithContext", varargs...)
	ret0, _ := ret[0].(*eks.UpdateClusterConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateClusterVersion mocks base method.
func (m *MockEKS) UpdateClusterVersion(arg0 *eks.UpdateClusterVersionInput) (*eks.UpdateClusterVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterVersion", arg0)
	ret0, _ := ret[0].(*eks.UpdateClusterVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateClusterVersionRequest mocks base method.
func (m *MockEKS) UpdateClusterVersionRequest(arg0 *eks.UpdateClusterVersionInput) (*request.Request, *eks.UpdateClusterVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateClusterVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.UpdateClusterVersionOutput)
	return ret0, ret1
}

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

// UpdateClusterVersionWithContext mocks base method.
func (m *MockEKS) UpdateClusterVersionWithContext(arg0 aws.Context, arg1 *eks.UpdateClusterVersionInput, arg2 ...request.Option) (*eks.UpdateClusterVersionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateClusterVersionWithContext", varargs...)
	ret0, _ := ret[0].(*eks.UpdateClusterVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNodegroupConfig mocks base method.
func (m *MockEKS) UpdateNodegroupConfig(arg0 *eks.UpdateNodegroupConfigInput) (*eks.UpdateNodegroupConfigOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNodegroupConfig", arg0)
	ret0, _ := ret[0].(*eks.UpdateNodegroupConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNodegroupConfigRequest mocks base method.
func (m *MockEKS) UpdateNodegroupConfigRequest(arg0 *eks.UpdateNodegroupConfigInput) (*request.Request, *eks.UpdateNodegroupConfigOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNodegroupConfigRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.UpdateNodegroupConfigOutput)
	return ret0, ret1
}

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

// UpdateNodegroupConfigWithContext mocks base method.
func (m *MockEKS) UpdateNodegroupConfigWithContext(arg0 aws.Context, arg1 *eks.UpdateNodegroupConfigInput, arg2 ...request.Option) (*eks.UpdateNodegroupConfigOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNodegroupConfigWithContext", varargs...)
	ret0, _ := ret[0].(*eks.UpdateNodegroupConfigOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNodegroupVersion mocks base method.
func (m *MockEKS) UpdateNodegroupVersion(arg0 *eks.UpdateNodegroupVersionInput) (*eks.UpdateNodegroupVersionOutput, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNodegroupVersion", arg0)
	ret0, _ := ret[0].(*eks.UpdateNodegroupVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// UpdateNodegroupVersionRequest mocks base method.
func (m *MockEKS) UpdateNodegroupVersionRequest(arg0 *eks.UpdateNodegroupVersionInput) (*request.Request, *eks.UpdateNodegroupVersionOutput) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNodegroupVersionRequest", arg0)
	ret0, _ := ret[0].(*request.Request)
	ret1, _ := ret[1].(*eks.UpdateNodegroupVersionOutput)
	return ret0, ret1
}

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

// UpdateNodegroupVersionWithContext mocks base method.
func (m *MockEKS) UpdateNodegroupVersionWithContext(arg0 aws.Context, arg1 *eks.UpdateNodegroupVersionInput, arg2 ...request.Option) (*eks.UpdateNodegroupVersionOutput, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateNodegroupVersionWithContext", varargs...)
	ret0, _ := ret[0].(*eks.UpdateNodegroupVersionOutput)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// WaitUntilAddonActive mocks base method.
func (m *MockEKS) WaitUntilAddonActive(arg0 *eks.DescribeAddonInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilAddonActive", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilAddonActiveWithContext mocks base method.
func (m *MockEKS) WaitUntilAddonActiveWithContext(arg0 aws.Context, arg1 *eks.DescribeAddonInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilAddonActiveWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilAddonDeleted mocks base method.
func (m *MockEKS) WaitUntilAddonDeleted(arg0 *eks.DescribeAddonInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilAddonDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilAddonDeletedWithContext mocks base method.
func (m *MockEKS) WaitUntilAddonDeletedWithContext(arg0 aws.Context, arg1 *eks.DescribeAddonInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilAddonDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilClusterActive mocks base method.
func (m *MockEKS) WaitUntilClusterActive(arg0 *eks.DescribeClusterInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilClusterActive", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilClusterActiveWithContext mocks base method.
func (m *MockEKS) WaitUntilClusterActiveWithContext(arg0 aws.Context, arg1 *eks.DescribeClusterInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilClusterActiveWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilClusterDeleted mocks base method.
func (m *MockEKS) WaitUntilClusterDeleted(arg0 *eks.DescribeClusterInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilClusterDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilClusterDeletedWithContext mocks base method.
func (m *MockEKS) WaitUntilClusterDeletedWithContext(arg0 aws.Context, arg1 *eks.DescribeClusterInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilClusterDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilFargateProfileActive mocks base method.
func (m *MockEKS) WaitUntilFargateProfileActive(arg0 *eks.DescribeFargateProfileInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilFargateProfileActive", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilFargateProfileActiveWithContext mocks base method.
func (m *MockEKS) WaitUntilFargateProfileActiveWithContext(arg0 aws.Context, arg1 *eks.DescribeFargateProfileInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilFargateProfileActiveWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilFargateProfileDeleted mocks base method.
func (m *MockEKS) WaitUntilFargateProfileDeleted(arg0 *eks.DescribeFargateProfileInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilFargateProfileDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilFargateProfileDeletedWithContext mocks base method.
func (m *MockEKS) WaitUntilFargateProfileDeletedWithContext(arg0 aws.Context, arg1 *eks.DescribeFargateProfileInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilFargateProfileDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilNodegroupActive mocks base method.
func (m *MockEKS) WaitUntilNodegroupActive(arg0 *eks.DescribeNodegroupInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilNodegroupActive", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilNodegroupActiveWithContext mocks base method.
func (m *MockEKS) WaitUntilNodegroupActiveWithContext(arg0 aws.Context, arg1 *eks.DescribeNodegroupInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilNodegroupActiveWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilNodegroupDeleted mocks base method.
func (m *MockEKS) WaitUntilNodegroupDeleted(arg0 *eks.DescribeNodegroupInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WaitUntilNodegroupDeleted", arg0)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WaitUntilNodegroupDeletedWithContext mocks base method.
func (m *MockEKS) WaitUntilNodegroupDeletedWithContext(arg0 aws.Context, arg1 *eks.DescribeNodegroupInput, arg2 ...request.WaiterOption) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WaitUntilNodegroupDeletedWithContext", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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