// Code generated by MockGen. DO NOT EDIT.
// Source: client.go
//
// Generated by this command:
//
//	mockgen-v0.6.0 -typed -source=client.go -destination=mock_client.go -package ocm ClusterServiceClientSpec
//

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

import (
	context "context"
	reflect "reflect"

	v1alpha1 "github.com/openshift-online/ocm-sdk-go/arohcp/v1alpha1"
	v1 "github.com/openshift-online/ocm-sdk-go/clustersmgmt/v1"
	gomock "go.uber.org/mock/gomock"
)

// MockClusterServiceClientSpec is a mock of ClusterServiceClientSpec interface.
type MockClusterServiceClientSpec struct {
	ctrl     *gomock.Controller
	recorder *MockClusterServiceClientSpecMockRecorder
	isgomock struct{}
}

// MockClusterServiceClientSpecMockRecorder is the mock recorder for MockClusterServiceClientSpec.
type MockClusterServiceClientSpecMockRecorder struct {
	mock *MockClusterServiceClientSpec
}

// NewMockClusterServiceClientSpec creates a new mock instance.
func NewMockClusterServiceClientSpec(ctrl *gomock.Controller) *MockClusterServiceClientSpec {
	mock := &MockClusterServiceClientSpec{ctrl: ctrl}
	mock.recorder = &MockClusterServiceClientSpecMockRecorder{mock}
	return mock
}

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

// DeleteBreakGlassCredentials mocks base method.
func (m *MockClusterServiceClientSpec) DeleteBreakGlassCredentials(ctx context.Context, clusterInternalID InternalID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteBreakGlassCredentials", ctx, clusterInternalID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteBreakGlassCredentials indicates an expected call of DeleteBreakGlassCredentials.
func (mr *MockClusterServiceClientSpecMockRecorder) DeleteBreakGlassCredentials(ctx, clusterInternalID any) *MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBreakGlassCredentials", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).DeleteBreakGlassCredentials), ctx, clusterInternalID)
	return &MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall{Call: call}
}

// MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall wrap *gomock.Call
type MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall) Return(arg0 error) *MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall) Do(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall) DoAndReturn(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteBreakGlassCredentialsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DeleteCluster mocks base method.
func (m *MockClusterServiceClientSpec) DeleteCluster(ctx context.Context, internalID InternalID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCluster", ctx, internalID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteCluster indicates an expected call of DeleteCluster.
func (mr *MockClusterServiceClientSpecMockRecorder) DeleteCluster(ctx, internalID any) *MockClusterServiceClientSpecDeleteClusterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteCluster", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).DeleteCluster), ctx, internalID)
	return &MockClusterServiceClientSpecDeleteClusterCall{Call: call}
}

// MockClusterServiceClientSpecDeleteClusterCall wrap *gomock.Call
type MockClusterServiceClientSpecDeleteClusterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecDeleteClusterCall) Return(arg0 error) *MockClusterServiceClientSpecDeleteClusterCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecDeleteClusterCall) Do(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteClusterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecDeleteClusterCall) DoAndReturn(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteClusterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DeleteExternalAuth mocks base method.
func (m *MockClusterServiceClientSpec) DeleteExternalAuth(ctx context.Context, internalID InternalID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteExternalAuth", ctx, internalID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteExternalAuth indicates an expected call of DeleteExternalAuth.
func (mr *MockClusterServiceClientSpecMockRecorder) DeleteExternalAuth(ctx, internalID any) *MockClusterServiceClientSpecDeleteExternalAuthCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteExternalAuth", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).DeleteExternalAuth), ctx, internalID)
	return &MockClusterServiceClientSpecDeleteExternalAuthCall{Call: call}
}

// MockClusterServiceClientSpecDeleteExternalAuthCall wrap *gomock.Call
type MockClusterServiceClientSpecDeleteExternalAuthCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecDeleteExternalAuthCall) Return(arg0 error) *MockClusterServiceClientSpecDeleteExternalAuthCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecDeleteExternalAuthCall) Do(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteExternalAuthCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecDeleteExternalAuthCall) DoAndReturn(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteExternalAuthCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DeleteNodePool mocks base method.
func (m *MockClusterServiceClientSpec) DeleteNodePool(ctx context.Context, internalID InternalID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNodePool", ctx, internalID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteNodePool indicates an expected call of DeleteNodePool.
func (mr *MockClusterServiceClientSpecMockRecorder) DeleteNodePool(ctx, internalID any) *MockClusterServiceClientSpecDeleteNodePoolCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNodePool", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).DeleteNodePool), ctx, internalID)
	return &MockClusterServiceClientSpecDeleteNodePoolCall{Call: call}
}

// MockClusterServiceClientSpecDeleteNodePoolCall wrap *gomock.Call
type MockClusterServiceClientSpecDeleteNodePoolCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecDeleteNodePoolCall) Return(arg0 error) *MockClusterServiceClientSpecDeleteNodePoolCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecDeleteNodePoolCall) Do(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteNodePoolCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecDeleteNodePoolCall) DoAndReturn(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteNodePoolCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// DeleteProvisionShard mocks base method.
func (m *MockClusterServiceClientSpec) DeleteProvisionShard(ctx context.Context, internalID InternalID) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteProvisionShard", ctx, internalID)
	ret0, _ := ret[0].(error)
	return ret0
}

// DeleteProvisionShard indicates an expected call of DeleteProvisionShard.
func (mr *MockClusterServiceClientSpecMockRecorder) DeleteProvisionShard(ctx, internalID any) *MockClusterServiceClientSpecDeleteProvisionShardCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteProvisionShard", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).DeleteProvisionShard), ctx, internalID)
	return &MockClusterServiceClientSpecDeleteProvisionShardCall{Call: call}
}

// MockClusterServiceClientSpecDeleteProvisionShardCall wrap *gomock.Call
type MockClusterServiceClientSpecDeleteProvisionShardCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecDeleteProvisionShardCall) Return(arg0 error) *MockClusterServiceClientSpecDeleteProvisionShardCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecDeleteProvisionShardCall) Do(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteProvisionShardCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecDeleteProvisionShardCall) DoAndReturn(f func(context.Context, InternalID) error) *MockClusterServiceClientSpecDeleteProvisionShardCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetBreakGlassCredential mocks base method.
func (m *MockClusterServiceClientSpec) GetBreakGlassCredential(ctx context.Context, internalID InternalID) (*v1.BreakGlassCredential, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBreakGlassCredential", ctx, internalID)
	ret0, _ := ret[0].(*v1.BreakGlassCredential)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBreakGlassCredential indicates an expected call of GetBreakGlassCredential.
func (mr *MockClusterServiceClientSpecMockRecorder) GetBreakGlassCredential(ctx, internalID any) *MockClusterServiceClientSpecGetBreakGlassCredentialCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBreakGlassCredential", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetBreakGlassCredential), ctx, internalID)
	return &MockClusterServiceClientSpecGetBreakGlassCredentialCall{Call: call}
}

// MockClusterServiceClientSpecGetBreakGlassCredentialCall wrap *gomock.Call
type MockClusterServiceClientSpecGetBreakGlassCredentialCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetBreakGlassCredentialCall) Return(arg0 *v1.BreakGlassCredential, arg1 error) *MockClusterServiceClientSpecGetBreakGlassCredentialCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetBreakGlassCredentialCall) Do(f func(context.Context, InternalID) (*v1.BreakGlassCredential, error)) *MockClusterServiceClientSpecGetBreakGlassCredentialCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetBreakGlassCredentialCall) DoAndReturn(f func(context.Context, InternalID) (*v1.BreakGlassCredential, error)) *MockClusterServiceClientSpecGetBreakGlassCredentialCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetCluster mocks base method.
func (m *MockClusterServiceClientSpec) GetCluster(ctx context.Context, internalID InternalID) (*v1alpha1.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetCluster", ctx, internalID)
	ret0, _ := ret[0].(*v1alpha1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCluster indicates an expected call of GetCluster.
func (mr *MockClusterServiceClientSpecMockRecorder) GetCluster(ctx, internalID any) *MockClusterServiceClientSpecGetClusterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCluster", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetCluster), ctx, internalID)
	return &MockClusterServiceClientSpecGetClusterCall{Call: call}
}

// MockClusterServiceClientSpecGetClusterCall wrap *gomock.Call
type MockClusterServiceClientSpecGetClusterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetClusterCall) Return(arg0 *v1alpha1.Cluster, arg1 error) *MockClusterServiceClientSpecGetClusterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetClusterCall) Do(f func(context.Context, InternalID) (*v1alpha1.Cluster, error)) *MockClusterServiceClientSpecGetClusterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetClusterCall) DoAndReturn(f func(context.Context, InternalID) (*v1alpha1.Cluster, error)) *MockClusterServiceClientSpecGetClusterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetClusterHypershiftDetails mocks base method.
func (m *MockClusterServiceClientSpec) GetClusterHypershiftDetails(ctx context.Context, internalID InternalID) (*v1.HypershiftConfig, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterHypershiftDetails", ctx, internalID)
	ret0, _ := ret[0].(*v1.HypershiftConfig)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterHypershiftDetails indicates an expected call of GetClusterHypershiftDetails.
func (mr *MockClusterServiceClientSpecMockRecorder) GetClusterHypershiftDetails(ctx, internalID any) *MockClusterServiceClientSpecGetClusterHypershiftDetailsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterHypershiftDetails", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetClusterHypershiftDetails), ctx, internalID)
	return &MockClusterServiceClientSpecGetClusterHypershiftDetailsCall{Call: call}
}

// MockClusterServiceClientSpecGetClusterHypershiftDetailsCall wrap *gomock.Call
type MockClusterServiceClientSpecGetClusterHypershiftDetailsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetClusterHypershiftDetailsCall) Return(arg0 *v1.HypershiftConfig, arg1 error) *MockClusterServiceClientSpecGetClusterHypershiftDetailsCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetClusterHypershiftDetailsCall) Do(f func(context.Context, InternalID) (*v1.HypershiftConfig, error)) *MockClusterServiceClientSpecGetClusterHypershiftDetailsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetClusterHypershiftDetailsCall) DoAndReturn(f func(context.Context, InternalID) (*v1.HypershiftConfig, error)) *MockClusterServiceClientSpecGetClusterHypershiftDetailsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetClusterInflightChecks mocks base method.
func (m *MockClusterServiceClientSpec) GetClusterInflightChecks(ctx context.Context, internalID InternalID) (*v1alpha1.InflightCheckList, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterInflightChecks", ctx, internalID)
	ret0, _ := ret[0].(*v1alpha1.InflightCheckList)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterInflightChecks indicates an expected call of GetClusterInflightChecks.
func (mr *MockClusterServiceClientSpecMockRecorder) GetClusterInflightChecks(ctx, internalID any) *MockClusterServiceClientSpecGetClusterInflightChecksCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterInflightChecks", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetClusterInflightChecks), ctx, internalID)
	return &MockClusterServiceClientSpecGetClusterInflightChecksCall{Call: call}
}

// MockClusterServiceClientSpecGetClusterInflightChecksCall wrap *gomock.Call
type MockClusterServiceClientSpecGetClusterInflightChecksCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetClusterInflightChecksCall) Return(arg0 *v1alpha1.InflightCheckList, arg1 error) *MockClusterServiceClientSpecGetClusterInflightChecksCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetClusterInflightChecksCall) Do(f func(context.Context, InternalID) (*v1alpha1.InflightCheckList, error)) *MockClusterServiceClientSpecGetClusterInflightChecksCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetClusterInflightChecksCall) DoAndReturn(f func(context.Context, InternalID) (*v1alpha1.InflightCheckList, error)) *MockClusterServiceClientSpecGetClusterInflightChecksCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetClusterProvisionShard mocks base method.
func (m *MockClusterServiceClientSpec) GetClusterProvisionShard(ctx context.Context, internalID InternalID) (*v1alpha1.ProvisionShard, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterProvisionShard", ctx, internalID)
	ret0, _ := ret[0].(*v1alpha1.ProvisionShard)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterProvisionShard indicates an expected call of GetClusterProvisionShard.
func (mr *MockClusterServiceClientSpecMockRecorder) GetClusterProvisionShard(ctx, internalID any) *MockClusterServiceClientSpecGetClusterProvisionShardCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterProvisionShard", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetClusterProvisionShard), ctx, internalID)
	return &MockClusterServiceClientSpecGetClusterProvisionShardCall{Call: call}
}

// MockClusterServiceClientSpecGetClusterProvisionShardCall wrap *gomock.Call
type MockClusterServiceClientSpecGetClusterProvisionShardCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetClusterProvisionShardCall) Return(arg0 *v1alpha1.ProvisionShard, arg1 error) *MockClusterServiceClientSpecGetClusterProvisionShardCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetClusterProvisionShardCall) Do(f func(context.Context, InternalID) (*v1alpha1.ProvisionShard, error)) *MockClusterServiceClientSpecGetClusterProvisionShardCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetClusterProvisionShardCall) DoAndReturn(f func(context.Context, InternalID) (*v1alpha1.ProvisionShard, error)) *MockClusterServiceClientSpecGetClusterProvisionShardCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetClusterStatus mocks base method.
func (m *MockClusterServiceClientSpec) GetClusterStatus(ctx context.Context, internalID InternalID) (*v1alpha1.ClusterStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetClusterStatus", ctx, internalID)
	ret0, _ := ret[0].(*v1alpha1.ClusterStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterStatus indicates an expected call of GetClusterStatus.
func (mr *MockClusterServiceClientSpecMockRecorder) GetClusterStatus(ctx, internalID any) *MockClusterServiceClientSpecGetClusterStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterStatus", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetClusterStatus), ctx, internalID)
	return &MockClusterServiceClientSpecGetClusterStatusCall{Call: call}
}

// MockClusterServiceClientSpecGetClusterStatusCall wrap *gomock.Call
type MockClusterServiceClientSpecGetClusterStatusCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetClusterStatusCall) Return(arg0 *v1alpha1.ClusterStatus, arg1 error) *MockClusterServiceClientSpecGetClusterStatusCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetClusterStatusCall) Do(f func(context.Context, InternalID) (*v1alpha1.ClusterStatus, error)) *MockClusterServiceClientSpecGetClusterStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetClusterStatusCall) DoAndReturn(f func(context.Context, InternalID) (*v1alpha1.ClusterStatus, error)) *MockClusterServiceClientSpecGetClusterStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetExternalAuth mocks base method.
func (m *MockClusterServiceClientSpec) GetExternalAuth(ctx context.Context, internalID InternalID) (*v1alpha1.ExternalAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetExternalAuth", ctx, internalID)
	ret0, _ := ret[0].(*v1alpha1.ExternalAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetExternalAuth indicates an expected call of GetExternalAuth.
func (mr *MockClusterServiceClientSpecMockRecorder) GetExternalAuth(ctx, internalID any) *MockClusterServiceClientSpecGetExternalAuthCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetExternalAuth", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetExternalAuth), ctx, internalID)
	return &MockClusterServiceClientSpecGetExternalAuthCall{Call: call}
}

// MockClusterServiceClientSpecGetExternalAuthCall wrap *gomock.Call
type MockClusterServiceClientSpecGetExternalAuthCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetExternalAuthCall) Return(arg0 *v1alpha1.ExternalAuth, arg1 error) *MockClusterServiceClientSpecGetExternalAuthCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetExternalAuthCall) Do(f func(context.Context, InternalID) (*v1alpha1.ExternalAuth, error)) *MockClusterServiceClientSpecGetExternalAuthCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetExternalAuthCall) DoAndReturn(f func(context.Context, InternalID) (*v1alpha1.ExternalAuth, error)) *MockClusterServiceClientSpecGetExternalAuthCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetNodePool mocks base method.
func (m *MockClusterServiceClientSpec) GetNodePool(ctx context.Context, internalID InternalID) (*v1alpha1.NodePool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodePool", ctx, internalID)
	ret0, _ := ret[0].(*v1alpha1.NodePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodePool indicates an expected call of GetNodePool.
func (mr *MockClusterServiceClientSpecMockRecorder) GetNodePool(ctx, internalID any) *MockClusterServiceClientSpecGetNodePoolCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodePool", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetNodePool), ctx, internalID)
	return &MockClusterServiceClientSpecGetNodePoolCall{Call: call}
}

// MockClusterServiceClientSpecGetNodePoolCall wrap *gomock.Call
type MockClusterServiceClientSpecGetNodePoolCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetNodePoolCall) Return(arg0 *v1alpha1.NodePool, arg1 error) *MockClusterServiceClientSpecGetNodePoolCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetNodePoolCall) Do(f func(context.Context, InternalID) (*v1alpha1.NodePool, error)) *MockClusterServiceClientSpecGetNodePoolCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetNodePoolCall) DoAndReturn(f func(context.Context, InternalID) (*v1alpha1.NodePool, error)) *MockClusterServiceClientSpecGetNodePoolCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetNodePoolStatus mocks base method.
func (m *MockClusterServiceClientSpec) GetNodePoolStatus(ctx context.Context, internalID InternalID) (*v1alpha1.NodePoolStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNodePoolStatus", ctx, internalID)
	ret0, _ := ret[0].(*v1alpha1.NodePoolStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodePoolStatus indicates an expected call of GetNodePoolStatus.
func (mr *MockClusterServiceClientSpecMockRecorder) GetNodePoolStatus(ctx, internalID any) *MockClusterServiceClientSpecGetNodePoolStatusCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodePoolStatus", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetNodePoolStatus), ctx, internalID)
	return &MockClusterServiceClientSpecGetNodePoolStatusCall{Call: call}
}

// MockClusterServiceClientSpecGetNodePoolStatusCall wrap *gomock.Call
type MockClusterServiceClientSpecGetNodePoolStatusCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetNodePoolStatusCall) Return(arg0 *v1alpha1.NodePoolStatus, arg1 error) *MockClusterServiceClientSpecGetNodePoolStatusCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetNodePoolStatusCall) Do(f func(context.Context, InternalID) (*v1alpha1.NodePoolStatus, error)) *MockClusterServiceClientSpecGetNodePoolStatusCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetNodePoolStatusCall) DoAndReturn(f func(context.Context, InternalID) (*v1alpha1.NodePoolStatus, error)) *MockClusterServiceClientSpecGetNodePoolStatusCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetProvisionShard mocks base method.
func (m *MockClusterServiceClientSpec) GetProvisionShard(ctx context.Context, internalID InternalID) (*v1alpha1.ProvisionShard, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetProvisionShard", ctx, internalID)
	ret0, _ := ret[0].(*v1alpha1.ProvisionShard)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetProvisionShard indicates an expected call of GetProvisionShard.
func (mr *MockClusterServiceClientSpecMockRecorder) GetProvisionShard(ctx, internalID any) *MockClusterServiceClientSpecGetProvisionShardCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetProvisionShard", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetProvisionShard), ctx, internalID)
	return &MockClusterServiceClientSpecGetProvisionShardCall{Call: call}
}

// MockClusterServiceClientSpecGetProvisionShardCall wrap *gomock.Call
type MockClusterServiceClientSpecGetProvisionShardCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetProvisionShardCall) Return(arg0 *v1alpha1.ProvisionShard, arg1 error) *MockClusterServiceClientSpecGetProvisionShardCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetProvisionShardCall) Do(f func(context.Context, InternalID) (*v1alpha1.ProvisionShard, error)) *MockClusterServiceClientSpecGetProvisionShardCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetProvisionShardCall) DoAndReturn(f func(context.Context, InternalID) (*v1alpha1.ProvisionShard, error)) *MockClusterServiceClientSpecGetProvisionShardCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// GetVersion mocks base method.
func (m *MockClusterServiceClientSpec) GetVersion(ctx context.Context, versionName string) (*v1alpha1.Version, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetVersion", ctx, versionName)
	ret0, _ := ret[0].(*v1alpha1.Version)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetVersion indicates an expected call of GetVersion.
func (mr *MockClusterServiceClientSpecMockRecorder) GetVersion(ctx, versionName any) *MockClusterServiceClientSpecGetVersionCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetVersion", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).GetVersion), ctx, versionName)
	return &MockClusterServiceClientSpecGetVersionCall{Call: call}
}

// MockClusterServiceClientSpecGetVersionCall wrap *gomock.Call
type MockClusterServiceClientSpecGetVersionCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecGetVersionCall) Return(arg0 *v1alpha1.Version, arg1 error) *MockClusterServiceClientSpecGetVersionCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecGetVersionCall) Do(f func(context.Context, string) (*v1alpha1.Version, error)) *MockClusterServiceClientSpecGetVersionCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecGetVersionCall) DoAndReturn(f func(context.Context, string) (*v1alpha1.Version, error)) *MockClusterServiceClientSpecGetVersionCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListBreakGlassCredentials mocks base method.
func (m *MockClusterServiceClientSpec) ListBreakGlassCredentials(clusterInternalID InternalID, searchExpression string) BreakGlassCredentialListIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListBreakGlassCredentials", clusterInternalID, searchExpression)
	ret0, _ := ret[0].(BreakGlassCredentialListIterator)
	return ret0
}

// ListBreakGlassCredentials indicates an expected call of ListBreakGlassCredentials.
func (mr *MockClusterServiceClientSpecMockRecorder) ListBreakGlassCredentials(clusterInternalID, searchExpression any) *MockClusterServiceClientSpecListBreakGlassCredentialsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListBreakGlassCredentials", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).ListBreakGlassCredentials), clusterInternalID, searchExpression)
	return &MockClusterServiceClientSpecListBreakGlassCredentialsCall{Call: call}
}

// MockClusterServiceClientSpecListBreakGlassCredentialsCall wrap *gomock.Call
type MockClusterServiceClientSpecListBreakGlassCredentialsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecListBreakGlassCredentialsCall) Return(arg0 BreakGlassCredentialListIterator) *MockClusterServiceClientSpecListBreakGlassCredentialsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecListBreakGlassCredentialsCall) Do(f func(InternalID, string) BreakGlassCredentialListIterator) *MockClusterServiceClientSpecListBreakGlassCredentialsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecListBreakGlassCredentialsCall) DoAndReturn(f func(InternalID, string) BreakGlassCredentialListIterator) *MockClusterServiceClientSpecListBreakGlassCredentialsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListClusters mocks base method.
func (m *MockClusterServiceClientSpec) ListClusters(searchExpression string) ClusterListIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusters", searchExpression)
	ret0, _ := ret[0].(ClusterListIterator)
	return ret0
}

// ListClusters indicates an expected call of ListClusters.
func (mr *MockClusterServiceClientSpecMockRecorder) ListClusters(searchExpression any) *MockClusterServiceClientSpecListClustersCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClusters", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).ListClusters), searchExpression)
	return &MockClusterServiceClientSpecListClustersCall{Call: call}
}

// MockClusterServiceClientSpecListClustersCall wrap *gomock.Call
type MockClusterServiceClientSpecListClustersCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecListClustersCall) Return(arg0 ClusterListIterator) *MockClusterServiceClientSpecListClustersCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecListClustersCall) Do(f func(string) ClusterListIterator) *MockClusterServiceClientSpecListClustersCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecListClustersCall) DoAndReturn(f func(string) ClusterListIterator) *MockClusterServiceClientSpecListClustersCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListControlPlaneUpgradePolicies mocks base method.
func (m *MockClusterServiceClientSpec) ListControlPlaneUpgradePolicies(clusterInternalID InternalID, orderBy string) ControlPlaneUpgradePolicyListIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListControlPlaneUpgradePolicies", clusterInternalID, orderBy)
	ret0, _ := ret[0].(ControlPlaneUpgradePolicyListIterator)
	return ret0
}

// ListControlPlaneUpgradePolicies indicates an expected call of ListControlPlaneUpgradePolicies.
func (mr *MockClusterServiceClientSpecMockRecorder) ListControlPlaneUpgradePolicies(clusterInternalID, orderBy any) *MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListControlPlaneUpgradePolicies", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).ListControlPlaneUpgradePolicies), clusterInternalID, orderBy)
	return &MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall{Call: call}
}

// MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall wrap *gomock.Call
type MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall) Return(arg0 ControlPlaneUpgradePolicyListIterator) *MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall) Do(f func(InternalID, string) ControlPlaneUpgradePolicyListIterator) *MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall) DoAndReturn(f func(InternalID, string) ControlPlaneUpgradePolicyListIterator) *MockClusterServiceClientSpecListControlPlaneUpgradePoliciesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListExternalAuths mocks base method.
func (m *MockClusterServiceClientSpec) ListExternalAuths(clusterInternalID InternalID, searchExpression string) ExternalAuthListIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListExternalAuths", clusterInternalID, searchExpression)
	ret0, _ := ret[0].(ExternalAuthListIterator)
	return ret0
}

// ListExternalAuths indicates an expected call of ListExternalAuths.
func (mr *MockClusterServiceClientSpecMockRecorder) ListExternalAuths(clusterInternalID, searchExpression any) *MockClusterServiceClientSpecListExternalAuthsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListExternalAuths", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).ListExternalAuths), clusterInternalID, searchExpression)
	return &MockClusterServiceClientSpecListExternalAuthsCall{Call: call}
}

// MockClusterServiceClientSpecListExternalAuthsCall wrap *gomock.Call
type MockClusterServiceClientSpecListExternalAuthsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecListExternalAuthsCall) Return(arg0 ExternalAuthListIterator) *MockClusterServiceClientSpecListExternalAuthsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecListExternalAuthsCall) Do(f func(InternalID, string) ExternalAuthListIterator) *MockClusterServiceClientSpecListExternalAuthsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecListExternalAuthsCall) DoAndReturn(f func(InternalID, string) ExternalAuthListIterator) *MockClusterServiceClientSpecListExternalAuthsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListNodePoolUpgradePolicies mocks base method.
func (m *MockClusterServiceClientSpec) ListNodePoolUpgradePolicies(nodePoolInternalID InternalID, orderBy string) NodePoolUpgradePolicyListIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodePoolUpgradePolicies", nodePoolInternalID, orderBy)
	ret0, _ := ret[0].(NodePoolUpgradePolicyListIterator)
	return ret0
}

// ListNodePoolUpgradePolicies indicates an expected call of ListNodePoolUpgradePolicies.
func (mr *MockClusterServiceClientSpecMockRecorder) ListNodePoolUpgradePolicies(nodePoolInternalID, orderBy any) *MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodePoolUpgradePolicies", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).ListNodePoolUpgradePolicies), nodePoolInternalID, orderBy)
	return &MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall{Call: call}
}

// MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall wrap *gomock.Call
type MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall) Return(arg0 NodePoolUpgradePolicyListIterator) *MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall) Do(f func(InternalID, string) NodePoolUpgradePolicyListIterator) *MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall) DoAndReturn(f func(InternalID, string) NodePoolUpgradePolicyListIterator) *MockClusterServiceClientSpecListNodePoolUpgradePoliciesCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListNodePools mocks base method.
func (m *MockClusterServiceClientSpec) ListNodePools(clusterInternalID InternalID, searchExpression string) NodePoolListIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNodePools", clusterInternalID, searchExpression)
	ret0, _ := ret[0].(NodePoolListIterator)
	return ret0
}

// ListNodePools indicates an expected call of ListNodePools.
func (mr *MockClusterServiceClientSpecMockRecorder) ListNodePools(clusterInternalID, searchExpression any) *MockClusterServiceClientSpecListNodePoolsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNodePools", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).ListNodePools), clusterInternalID, searchExpression)
	return &MockClusterServiceClientSpecListNodePoolsCall{Call: call}
}

// MockClusterServiceClientSpecListNodePoolsCall wrap *gomock.Call
type MockClusterServiceClientSpecListNodePoolsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecListNodePoolsCall) Return(arg0 NodePoolListIterator) *MockClusterServiceClientSpecListNodePoolsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecListNodePoolsCall) Do(f func(InternalID, string) NodePoolListIterator) *MockClusterServiceClientSpecListNodePoolsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecListNodePoolsCall) DoAndReturn(f func(InternalID, string) NodePoolListIterator) *MockClusterServiceClientSpecListNodePoolsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListProvisionShards mocks base method.
func (m *MockClusterServiceClientSpec) ListProvisionShards() ProvisionShardListIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListProvisionShards")
	ret0, _ := ret[0].(ProvisionShardListIterator)
	return ret0
}

// ListProvisionShards indicates an expected call of ListProvisionShards.
func (mr *MockClusterServiceClientSpecMockRecorder) ListProvisionShards() *MockClusterServiceClientSpecListProvisionShardsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProvisionShards", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).ListProvisionShards))
	return &MockClusterServiceClientSpecListProvisionShardsCall{Call: call}
}

// MockClusterServiceClientSpecListProvisionShardsCall wrap *gomock.Call
type MockClusterServiceClientSpecListProvisionShardsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecListProvisionShardsCall) Return(arg0 ProvisionShardListIterator) *MockClusterServiceClientSpecListProvisionShardsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecListProvisionShardsCall) Do(f func() ProvisionShardListIterator) *MockClusterServiceClientSpecListProvisionShardsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecListProvisionShardsCall) DoAndReturn(f func() ProvisionShardListIterator) *MockClusterServiceClientSpecListProvisionShardsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ListVersions mocks base method.
func (m *MockClusterServiceClientSpec) ListVersions() *VersionsListIterator {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListVersions")
	ret0, _ := ret[0].(*VersionsListIterator)
	return ret0
}

// ListVersions indicates an expected call of ListVersions.
func (mr *MockClusterServiceClientSpecMockRecorder) ListVersions() *MockClusterServiceClientSpecListVersionsCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListVersions", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).ListVersions))
	return &MockClusterServiceClientSpecListVersionsCall{Call: call}
}

// MockClusterServiceClientSpecListVersionsCall wrap *gomock.Call
type MockClusterServiceClientSpecListVersionsCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecListVersionsCall) Return(arg0 *VersionsListIterator) *MockClusterServiceClientSpecListVersionsCall {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecListVersionsCall) Do(f func() *VersionsListIterator) *MockClusterServiceClientSpecListVersionsCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecListVersionsCall) DoAndReturn(f func() *VersionsListIterator) *MockClusterServiceClientSpecListVersionsCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostBreakGlassCredential mocks base method.
func (m *MockClusterServiceClientSpec) PostBreakGlassCredential(ctx context.Context, clusterInternalID InternalID) (*v1.BreakGlassCredential, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostBreakGlassCredential", ctx, clusterInternalID)
	ret0, _ := ret[0].(*v1.BreakGlassCredential)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostBreakGlassCredential indicates an expected call of PostBreakGlassCredential.
func (mr *MockClusterServiceClientSpecMockRecorder) PostBreakGlassCredential(ctx, clusterInternalID any) *MockClusterServiceClientSpecPostBreakGlassCredentialCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostBreakGlassCredential", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).PostBreakGlassCredential), ctx, clusterInternalID)
	return &MockClusterServiceClientSpecPostBreakGlassCredentialCall{Call: call}
}

// MockClusterServiceClientSpecPostBreakGlassCredentialCall wrap *gomock.Call
type MockClusterServiceClientSpecPostBreakGlassCredentialCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecPostBreakGlassCredentialCall) Return(arg0 *v1.BreakGlassCredential, arg1 error) *MockClusterServiceClientSpecPostBreakGlassCredentialCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecPostBreakGlassCredentialCall) Do(f func(context.Context, InternalID) (*v1.BreakGlassCredential, error)) *MockClusterServiceClientSpecPostBreakGlassCredentialCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecPostBreakGlassCredentialCall) DoAndReturn(f func(context.Context, InternalID) (*v1.BreakGlassCredential, error)) *MockClusterServiceClientSpecPostBreakGlassCredentialCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostCluster mocks base method.
func (m *MockClusterServiceClientSpec) PostCluster(ctx context.Context, clusterBuilder *v1alpha1.ClusterBuilder) (*v1alpha1.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostCluster", ctx, clusterBuilder)
	ret0, _ := ret[0].(*v1alpha1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostCluster indicates an expected call of PostCluster.
func (mr *MockClusterServiceClientSpecMockRecorder) PostCluster(ctx, clusterBuilder any) *MockClusterServiceClientSpecPostClusterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostCluster", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).PostCluster), ctx, clusterBuilder)
	return &MockClusterServiceClientSpecPostClusterCall{Call: call}
}

// MockClusterServiceClientSpecPostClusterCall wrap *gomock.Call
type MockClusterServiceClientSpecPostClusterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecPostClusterCall) Return(arg0 *v1alpha1.Cluster, arg1 error) *MockClusterServiceClientSpecPostClusterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecPostClusterCall) Do(f func(context.Context, *v1alpha1.ClusterBuilder) (*v1alpha1.Cluster, error)) *MockClusterServiceClientSpecPostClusterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecPostClusterCall) DoAndReturn(f func(context.Context, *v1alpha1.ClusterBuilder) (*v1alpha1.Cluster, error)) *MockClusterServiceClientSpecPostClusterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostControlPlaneUpgradePolicy mocks base method.
func (m *MockClusterServiceClientSpec) PostControlPlaneUpgradePolicy(ctx context.Context, clusterInternalID InternalID, builder *v1alpha1.ControlPlaneUpgradePolicyBuilder) (*v1alpha1.ControlPlaneUpgradePolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostControlPlaneUpgradePolicy", ctx, clusterInternalID, builder)
	ret0, _ := ret[0].(*v1alpha1.ControlPlaneUpgradePolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostControlPlaneUpgradePolicy indicates an expected call of PostControlPlaneUpgradePolicy.
func (mr *MockClusterServiceClientSpecMockRecorder) PostControlPlaneUpgradePolicy(ctx, clusterInternalID, builder any) *MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostControlPlaneUpgradePolicy", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).PostControlPlaneUpgradePolicy), ctx, clusterInternalID, builder)
	return &MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall{Call: call}
}

// MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall wrap *gomock.Call
type MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall) Return(arg0 *v1alpha1.ControlPlaneUpgradePolicy, arg1 error) *MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall) Do(f func(context.Context, InternalID, *v1alpha1.ControlPlaneUpgradePolicyBuilder) (*v1alpha1.ControlPlaneUpgradePolicy, error)) *MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall) DoAndReturn(f func(context.Context, InternalID, *v1alpha1.ControlPlaneUpgradePolicyBuilder) (*v1alpha1.ControlPlaneUpgradePolicy, error)) *MockClusterServiceClientSpecPostControlPlaneUpgradePolicyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostExternalAuth mocks base method.
func (m *MockClusterServiceClientSpec) PostExternalAuth(ctx context.Context, clusterInternalID InternalID, builder *v1alpha1.ExternalAuthBuilder) (*v1alpha1.ExternalAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostExternalAuth", ctx, clusterInternalID, builder)
	ret0, _ := ret[0].(*v1alpha1.ExternalAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostExternalAuth indicates an expected call of PostExternalAuth.
func (mr *MockClusterServiceClientSpecMockRecorder) PostExternalAuth(ctx, clusterInternalID, builder any) *MockClusterServiceClientSpecPostExternalAuthCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostExternalAuth", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).PostExternalAuth), ctx, clusterInternalID, builder)
	return &MockClusterServiceClientSpecPostExternalAuthCall{Call: call}
}

// MockClusterServiceClientSpecPostExternalAuthCall wrap *gomock.Call
type MockClusterServiceClientSpecPostExternalAuthCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecPostExternalAuthCall) Return(arg0 *v1alpha1.ExternalAuth, arg1 error) *MockClusterServiceClientSpecPostExternalAuthCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecPostExternalAuthCall) Do(f func(context.Context, InternalID, *v1alpha1.ExternalAuthBuilder) (*v1alpha1.ExternalAuth, error)) *MockClusterServiceClientSpecPostExternalAuthCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecPostExternalAuthCall) DoAndReturn(f func(context.Context, InternalID, *v1alpha1.ExternalAuthBuilder) (*v1alpha1.ExternalAuth, error)) *MockClusterServiceClientSpecPostExternalAuthCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostNodePool mocks base method.
func (m *MockClusterServiceClientSpec) PostNodePool(ctx context.Context, clusterInternalID InternalID, builder *v1alpha1.NodePoolBuilder) (*v1alpha1.NodePool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostNodePool", ctx, clusterInternalID, builder)
	ret0, _ := ret[0].(*v1alpha1.NodePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostNodePool indicates an expected call of PostNodePool.
func (mr *MockClusterServiceClientSpecMockRecorder) PostNodePool(ctx, clusterInternalID, builder any) *MockClusterServiceClientSpecPostNodePoolCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostNodePool", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).PostNodePool), ctx, clusterInternalID, builder)
	return &MockClusterServiceClientSpecPostNodePoolCall{Call: call}
}

// MockClusterServiceClientSpecPostNodePoolCall wrap *gomock.Call
type MockClusterServiceClientSpecPostNodePoolCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecPostNodePoolCall) Return(arg0 *v1alpha1.NodePool, arg1 error) *MockClusterServiceClientSpecPostNodePoolCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecPostNodePoolCall) Do(f func(context.Context, InternalID, *v1alpha1.NodePoolBuilder) (*v1alpha1.NodePool, error)) *MockClusterServiceClientSpecPostNodePoolCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecPostNodePoolCall) DoAndReturn(f func(context.Context, InternalID, *v1alpha1.NodePoolBuilder) (*v1alpha1.NodePool, error)) *MockClusterServiceClientSpecPostNodePoolCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostNodePoolUpgradePolicy mocks base method.
func (m *MockClusterServiceClientSpec) PostNodePoolUpgradePolicy(ctx context.Context, nodePoolInternalID InternalID, builder *v1alpha1.NodePoolUpgradePolicyBuilder) (*v1alpha1.NodePoolUpgradePolicy, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostNodePoolUpgradePolicy", ctx, nodePoolInternalID, builder)
	ret0, _ := ret[0].(*v1alpha1.NodePoolUpgradePolicy)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostNodePoolUpgradePolicy indicates an expected call of PostNodePoolUpgradePolicy.
func (mr *MockClusterServiceClientSpecMockRecorder) PostNodePoolUpgradePolicy(ctx, nodePoolInternalID, builder any) *MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostNodePoolUpgradePolicy", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).PostNodePoolUpgradePolicy), ctx, nodePoolInternalID, builder)
	return &MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall{Call: call}
}

// MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall wrap *gomock.Call
type MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall) Return(arg0 *v1alpha1.NodePoolUpgradePolicy, arg1 error) *MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall) Do(f func(context.Context, InternalID, *v1alpha1.NodePoolUpgradePolicyBuilder) (*v1alpha1.NodePoolUpgradePolicy, error)) *MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall) DoAndReturn(f func(context.Context, InternalID, *v1alpha1.NodePoolUpgradePolicyBuilder) (*v1alpha1.NodePoolUpgradePolicy, error)) *MockClusterServiceClientSpecPostNodePoolUpgradePolicyCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// PostProvisionShard mocks base method.
func (m *MockClusterServiceClientSpec) PostProvisionShard(ctx context.Context, builder *v1alpha1.ProvisionShardBuilder) (*v1alpha1.ProvisionShard, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PostProvisionShard", ctx, builder)
	ret0, _ := ret[0].(*v1alpha1.ProvisionShard)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PostProvisionShard indicates an expected call of PostProvisionShard.
func (mr *MockClusterServiceClientSpecMockRecorder) PostProvisionShard(ctx, builder any) *MockClusterServiceClientSpecPostProvisionShardCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostProvisionShard", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).PostProvisionShard), ctx, builder)
	return &MockClusterServiceClientSpecPostProvisionShardCall{Call: call}
}

// MockClusterServiceClientSpecPostProvisionShardCall wrap *gomock.Call
type MockClusterServiceClientSpecPostProvisionShardCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecPostProvisionShardCall) Return(arg0 *v1alpha1.ProvisionShard, arg1 error) *MockClusterServiceClientSpecPostProvisionShardCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecPostProvisionShardCall) Do(f func(context.Context, *v1alpha1.ProvisionShardBuilder) (*v1alpha1.ProvisionShard, error)) *MockClusterServiceClientSpecPostProvisionShardCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecPostProvisionShardCall) DoAndReturn(f func(context.Context, *v1alpha1.ProvisionShardBuilder) (*v1alpha1.ProvisionShard, error)) *MockClusterServiceClientSpecPostProvisionShardCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdateCluster mocks base method.
func (m *MockClusterServiceClientSpec) UpdateCluster(ctx context.Context, internalID InternalID, builder *v1alpha1.ClusterBuilder) (*v1alpha1.Cluster, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCluster", ctx, internalID, builder)
	ret0, _ := ret[0].(*v1alpha1.Cluster)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCluster indicates an expected call of UpdateCluster.
func (mr *MockClusterServiceClientSpecMockRecorder) UpdateCluster(ctx, internalID, builder any) *MockClusterServiceClientSpecUpdateClusterCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).UpdateCluster), ctx, internalID, builder)
	return &MockClusterServiceClientSpecUpdateClusterCall{Call: call}
}

// MockClusterServiceClientSpecUpdateClusterCall wrap *gomock.Call
type MockClusterServiceClientSpecUpdateClusterCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecUpdateClusterCall) Return(arg0 *v1alpha1.Cluster, arg1 error) *MockClusterServiceClientSpecUpdateClusterCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecUpdateClusterCall) Do(f func(context.Context, InternalID, *v1alpha1.ClusterBuilder) (*v1alpha1.Cluster, error)) *MockClusterServiceClientSpecUpdateClusterCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecUpdateClusterCall) DoAndReturn(f func(context.Context, InternalID, *v1alpha1.ClusterBuilder) (*v1alpha1.Cluster, error)) *MockClusterServiceClientSpecUpdateClusterCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdateExternalAuth mocks base method.
func (m *MockClusterServiceClientSpec) UpdateExternalAuth(ctx context.Context, internalID InternalID, builder *v1alpha1.ExternalAuthBuilder) (*v1alpha1.ExternalAuth, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateExternalAuth", ctx, internalID, builder)
	ret0, _ := ret[0].(*v1alpha1.ExternalAuth)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateExternalAuth indicates an expected call of UpdateExternalAuth.
func (mr *MockClusterServiceClientSpecMockRecorder) UpdateExternalAuth(ctx, internalID, builder any) *MockClusterServiceClientSpecUpdateExternalAuthCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateExternalAuth", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).UpdateExternalAuth), ctx, internalID, builder)
	return &MockClusterServiceClientSpecUpdateExternalAuthCall{Call: call}
}

// MockClusterServiceClientSpecUpdateExternalAuthCall wrap *gomock.Call
type MockClusterServiceClientSpecUpdateExternalAuthCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecUpdateExternalAuthCall) Return(arg0 *v1alpha1.ExternalAuth, arg1 error) *MockClusterServiceClientSpecUpdateExternalAuthCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecUpdateExternalAuthCall) Do(f func(context.Context, InternalID, *v1alpha1.ExternalAuthBuilder) (*v1alpha1.ExternalAuth, error)) *MockClusterServiceClientSpecUpdateExternalAuthCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecUpdateExternalAuthCall) DoAndReturn(f func(context.Context, InternalID, *v1alpha1.ExternalAuthBuilder) (*v1alpha1.ExternalAuth, error)) *MockClusterServiceClientSpecUpdateExternalAuthCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdateNodePool mocks base method.
func (m *MockClusterServiceClientSpec) UpdateNodePool(ctx context.Context, internalID InternalID, builder *v1alpha1.NodePoolBuilder) (*v1alpha1.NodePool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateNodePool", ctx, internalID, builder)
	ret0, _ := ret[0].(*v1alpha1.NodePool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateNodePool indicates an expected call of UpdateNodePool.
func (mr *MockClusterServiceClientSpecMockRecorder) UpdateNodePool(ctx, internalID, builder any) *MockClusterServiceClientSpecUpdateNodePoolCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateNodePool", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).UpdateNodePool), ctx, internalID, builder)
	return &MockClusterServiceClientSpecUpdateNodePoolCall{Call: call}
}

// MockClusterServiceClientSpecUpdateNodePoolCall wrap *gomock.Call
type MockClusterServiceClientSpecUpdateNodePoolCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecUpdateNodePoolCall) Return(arg0 *v1alpha1.NodePool, arg1 error) *MockClusterServiceClientSpecUpdateNodePoolCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecUpdateNodePoolCall) Do(f func(context.Context, InternalID, *v1alpha1.NodePoolBuilder) (*v1alpha1.NodePool, error)) *MockClusterServiceClientSpecUpdateNodePoolCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecUpdateNodePoolCall) DoAndReturn(f func(context.Context, InternalID, *v1alpha1.NodePoolBuilder) (*v1alpha1.NodePool, error)) *MockClusterServiceClientSpecUpdateNodePoolCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// UpdateProvisionShard mocks base method.
func (m *MockClusterServiceClientSpec) UpdateProvisionShard(ctx context.Context, internalID InternalID, builder *v1alpha1.ProvisionShardBuilder) (*v1alpha1.ProvisionShard, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateProvisionShard", ctx, internalID, builder)
	ret0, _ := ret[0].(*v1alpha1.ProvisionShard)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateProvisionShard indicates an expected call of UpdateProvisionShard.
func (mr *MockClusterServiceClientSpecMockRecorder) UpdateProvisionShard(ctx, internalID, builder any) *MockClusterServiceClientSpecUpdateProvisionShardCall {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateProvisionShard", reflect.TypeOf((*MockClusterServiceClientSpec)(nil).UpdateProvisionShard), ctx, internalID, builder)
	return &MockClusterServiceClientSpecUpdateProvisionShardCall{Call: call}
}

// MockClusterServiceClientSpecUpdateProvisionShardCall wrap *gomock.Call
type MockClusterServiceClientSpecUpdateProvisionShardCall struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockClusterServiceClientSpecUpdateProvisionShardCall) Return(arg0 *v1alpha1.ProvisionShard, arg1 error) *MockClusterServiceClientSpecUpdateProvisionShardCall {
	c.Call = c.Call.Return(arg0, arg1)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockClusterServiceClientSpecUpdateProvisionShardCall) Do(f func(context.Context, InternalID, *v1alpha1.ProvisionShardBuilder) (*v1alpha1.ProvisionShard, error)) *MockClusterServiceClientSpecUpdateProvisionShardCall {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockClusterServiceClientSpecUpdateProvisionShardCall) DoAndReturn(f func(context.Context, InternalID, *v1alpha1.ProvisionShardBuilder) (*v1alpha1.ProvisionShard, error)) *MockClusterServiceClientSpecUpdateProvisionShardCall {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
