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

// Code generated by MockGen. DO NOT EDIT.
// Source: ./cloudstack/ClusterService.go

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockClusterServiceIface is a mock of ClusterServiceIface interface.
type MockClusterServiceIface struct {
	ctrl     *gomock.Controller
	recorder *MockClusterServiceIfaceMockRecorder
}

// MockClusterServiceIfaceMockRecorder is the mock recorder for MockClusterServiceIface.
type MockClusterServiceIfaceMockRecorder struct {
	mock *MockClusterServiceIface
}

// NewMockClusterServiceIface creates a new mock instance.
func NewMockClusterServiceIface(ctrl *gomock.Controller) *MockClusterServiceIface {
	mock := &MockClusterServiceIface{ctrl: ctrl}
	mock.recorder = &MockClusterServiceIfaceMockRecorder{mock}
	return mock
}

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

// AddCluster mocks base method.
func (m *MockClusterServiceIface) AddCluster(p *AddClusterParams) (*AddClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddCluster", p)
	ret0, _ := ret[0].(*AddClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AddCluster indicates an expected call of AddCluster.
func (mr *MockClusterServiceIfaceMockRecorder) AddCluster(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddCluster", reflect.TypeOf((*MockClusterServiceIface)(nil).AddCluster), p)
}

// DedicateCluster mocks base method.
func (m *MockClusterServiceIface) DedicateCluster(p *DedicateClusterParams) (*DedicateClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DedicateCluster", p)
	ret0, _ := ret[0].(*DedicateClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DedicateCluster indicates an expected call of DedicateCluster.
func (mr *MockClusterServiceIfaceMockRecorder) DedicateCluster(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DedicateCluster", reflect.TypeOf((*MockClusterServiceIface)(nil).DedicateCluster), p)
}

// DeleteCluster mocks base method.
func (m *MockClusterServiceIface) DeleteCluster(p *DeleteClusterParams) (*DeleteClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteCluster", p)
	ret0, _ := ret[0].(*DeleteClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// DisableHAForCluster mocks base method.
func (m *MockClusterServiceIface) DisableHAForCluster(p *DisableHAForClusterParams) (*DisableHAForClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableHAForCluster", p)
	ret0, _ := ret[0].(*DisableHAForClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableHAForCluster indicates an expected call of DisableHAForCluster.
func (mr *MockClusterServiceIfaceMockRecorder) DisableHAForCluster(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableHAForCluster", reflect.TypeOf((*MockClusterServiceIface)(nil).DisableHAForCluster), p)
}

// DisableOutOfBandManagementForCluster mocks base method.
func (m *MockClusterServiceIface) DisableOutOfBandManagementForCluster(p *DisableOutOfBandManagementForClusterParams) (*DisableOutOfBandManagementForClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisableOutOfBandManagementForCluster", p)
	ret0, _ := ret[0].(*DisableOutOfBandManagementForClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DisableOutOfBandManagementForCluster indicates an expected call of DisableOutOfBandManagementForCluster.
func (mr *MockClusterServiceIfaceMockRecorder) DisableOutOfBandManagementForCluster(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisableOutOfBandManagementForCluster", reflect.TypeOf((*MockClusterServiceIface)(nil).DisableOutOfBandManagementForCluster), p)
}

// EnableHAForCluster mocks base method.
func (m *MockClusterServiceIface) EnableHAForCluster(p *EnableHAForClusterParams) (*EnableHAForClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableHAForCluster", p)
	ret0, _ := ret[0].(*EnableHAForClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableHAForCluster indicates an expected call of EnableHAForCluster.
func (mr *MockClusterServiceIfaceMockRecorder) EnableHAForCluster(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableHAForCluster", reflect.TypeOf((*MockClusterServiceIface)(nil).EnableHAForCluster), p)
}

// EnableOutOfBandManagementForCluster mocks base method.
func (m *MockClusterServiceIface) EnableOutOfBandManagementForCluster(p *EnableOutOfBandManagementForClusterParams) (*EnableOutOfBandManagementForClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnableOutOfBandManagementForCluster", p)
	ret0, _ := ret[0].(*EnableOutOfBandManagementForClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EnableOutOfBandManagementForCluster indicates an expected call of EnableOutOfBandManagementForCluster.
func (mr *MockClusterServiceIfaceMockRecorder) EnableOutOfBandManagementForCluster(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnableOutOfBandManagementForCluster", reflect.TypeOf((*MockClusterServiceIface)(nil).EnableOutOfBandManagementForCluster), p)
}

// GetClusterByID mocks base method.
func (m *MockClusterServiceIface) GetClusterByID(id string, opts ...OptionFunc) (*Cluster, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterByID", varargs...)
	ret0, _ := ret[0].(*Cluster)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetClusterByID indicates an expected call of GetClusterByID.
func (mr *MockClusterServiceIfaceMockRecorder) GetClusterByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterByID", reflect.TypeOf((*MockClusterServiceIface)(nil).GetClusterByID), varargs...)
}

// GetClusterByName mocks base method.
func (m *MockClusterServiceIface) GetClusterByName(name string, opts ...OptionFunc) (*Cluster, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterByName", varargs...)
	ret0, _ := ret[0].(*Cluster)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetClusterByName indicates an expected call of GetClusterByName.
func (mr *MockClusterServiceIfaceMockRecorder) GetClusterByName(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterByName", reflect.TypeOf((*MockClusterServiceIface)(nil).GetClusterByName), varargs...)
}

// GetClusterID mocks base method.
func (m *MockClusterServiceIface) GetClusterID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetClusterID indicates an expected call of GetClusterID.
func (mr *MockClusterServiceIfaceMockRecorder) GetClusterID(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterID", reflect.TypeOf((*MockClusterServiceIface)(nil).GetClusterID), varargs...)
}

// GetClustersMetricByID mocks base method.
func (m *MockClusterServiceIface) GetClustersMetricByID(id string, opts ...OptionFunc) (*ClustersMetric, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClustersMetricByID", varargs...)
	ret0, _ := ret[0].(*ClustersMetric)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetClustersMetricByID indicates an expected call of GetClustersMetricByID.
func (mr *MockClusterServiceIfaceMockRecorder) GetClustersMetricByID(id interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClustersMetricByID", reflect.TypeOf((*MockClusterServiceIface)(nil).GetClustersMetricByID), varargs...)
}

// GetClustersMetricByName mocks base method.
func (m *MockClusterServiceIface) GetClustersMetricByName(name string, opts ...OptionFunc) (*ClustersMetric, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClustersMetricByName", varargs...)
	ret0, _ := ret[0].(*ClustersMetric)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetClustersMetricByName indicates an expected call of GetClustersMetricByName.
func (mr *MockClusterServiceIfaceMockRecorder) GetClustersMetricByName(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClustersMetricByName", reflect.TypeOf((*MockClusterServiceIface)(nil).GetClustersMetricByName), varargs...)
}

// GetClustersMetricID mocks base method.
func (m *MockClusterServiceIface) GetClustersMetricID(name string, opts ...OptionFunc) (string, int, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClustersMetricID", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetClustersMetricID indicates an expected call of GetClustersMetricID.
func (mr *MockClusterServiceIfaceMockRecorder) GetClustersMetricID(name interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClustersMetricID", reflect.TypeOf((*MockClusterServiceIface)(nil).GetClustersMetricID), varargs...)
}

// ListClusters mocks base method.
func (m *MockClusterServiceIface) ListClusters(p *ListClustersParams) (*ListClustersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClusters", p)
	ret0, _ := ret[0].(*ListClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ListClustersMetrics mocks base method.
func (m *MockClusterServiceIface) ListClustersMetrics(p *ListClustersMetricsParams) (*ListClustersMetricsResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListClustersMetrics", p)
	ret0, _ := ret[0].(*ListClustersMetricsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListClustersMetrics indicates an expected call of ListClustersMetrics.
func (mr *MockClusterServiceIfaceMockRecorder) ListClustersMetrics(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListClustersMetrics", reflect.TypeOf((*MockClusterServiceIface)(nil).ListClustersMetrics), p)
}

// ListDedicatedClusters mocks base method.
func (m *MockClusterServiceIface) ListDedicatedClusters(p *ListDedicatedClustersParams) (*ListDedicatedClustersResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListDedicatedClusters", p)
	ret0, _ := ret[0].(*ListDedicatedClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDedicatedClusters indicates an expected call of ListDedicatedClusters.
func (mr *MockClusterServiceIfaceMockRecorder) ListDedicatedClusters(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDedicatedClusters", reflect.TypeOf((*MockClusterServiceIface)(nil).ListDedicatedClusters), p)
}

// NewAddClusterParams mocks base method.
func (m *MockClusterServiceIface) NewAddClusterParams(clustername, clustertype, hypervisor, podid, zoneid string) *AddClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewAddClusterParams", clustername, clustertype, hypervisor, podid, zoneid)
	ret0, _ := ret[0].(*AddClusterParams)
	return ret0
}

// NewAddClusterParams indicates an expected call of NewAddClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewAddClusterParams(clustername, clustertype, hypervisor, podid, zoneid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAddClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewAddClusterParams), clustername, clustertype, hypervisor, podid, zoneid)
}

// NewDedicateClusterParams mocks base method.
func (m *MockClusterServiceIface) NewDedicateClusterParams(clusterid, domainid string) *DedicateClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDedicateClusterParams", clusterid, domainid)
	ret0, _ := ret[0].(*DedicateClusterParams)
	return ret0
}

// NewDedicateClusterParams indicates an expected call of NewDedicateClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewDedicateClusterParams(clusterid, domainid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDedicateClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewDedicateClusterParams), clusterid, domainid)
}

// NewDeleteClusterParams mocks base method.
func (m *MockClusterServiceIface) NewDeleteClusterParams(id string) *DeleteClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDeleteClusterParams", id)
	ret0, _ := ret[0].(*DeleteClusterParams)
	return ret0
}

// NewDeleteClusterParams indicates an expected call of NewDeleteClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewDeleteClusterParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDeleteClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewDeleteClusterParams), id)
}

// NewDisableHAForClusterParams mocks base method.
func (m *MockClusterServiceIface) NewDisableHAForClusterParams(clusterid string) *DisableHAForClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDisableHAForClusterParams", clusterid)
	ret0, _ := ret[0].(*DisableHAForClusterParams)
	return ret0
}

// NewDisableHAForClusterParams indicates an expected call of NewDisableHAForClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewDisableHAForClusterParams(clusterid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDisableHAForClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewDisableHAForClusterParams), clusterid)
}

// NewDisableOutOfBandManagementForClusterParams mocks base method.
func (m *MockClusterServiceIface) NewDisableOutOfBandManagementForClusterParams(clusterid string) *DisableOutOfBandManagementForClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDisableOutOfBandManagementForClusterParams", clusterid)
	ret0, _ := ret[0].(*DisableOutOfBandManagementForClusterParams)
	return ret0
}

// NewDisableOutOfBandManagementForClusterParams indicates an expected call of NewDisableOutOfBandManagementForClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewDisableOutOfBandManagementForClusterParams(clusterid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDisableOutOfBandManagementForClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewDisableOutOfBandManagementForClusterParams), clusterid)
}

// NewEnableHAForClusterParams mocks base method.
func (m *MockClusterServiceIface) NewEnableHAForClusterParams(clusterid string) *EnableHAForClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewEnableHAForClusterParams", clusterid)
	ret0, _ := ret[0].(*EnableHAForClusterParams)
	return ret0
}

// NewEnableHAForClusterParams indicates an expected call of NewEnableHAForClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewEnableHAForClusterParams(clusterid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewEnableHAForClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewEnableHAForClusterParams), clusterid)
}

// NewEnableOutOfBandManagementForClusterParams mocks base method.
func (m *MockClusterServiceIface) NewEnableOutOfBandManagementForClusterParams(clusterid string) *EnableOutOfBandManagementForClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewEnableOutOfBandManagementForClusterParams", clusterid)
	ret0, _ := ret[0].(*EnableOutOfBandManagementForClusterParams)
	return ret0
}

// NewEnableOutOfBandManagementForClusterParams indicates an expected call of NewEnableOutOfBandManagementForClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewEnableOutOfBandManagementForClusterParams(clusterid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewEnableOutOfBandManagementForClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewEnableOutOfBandManagementForClusterParams), clusterid)
}

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

// NewListClustersMetricsParams indicates an expected call of NewListClustersMetricsParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewListClustersMetricsParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListClustersMetricsParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewListClustersMetricsParams))
}

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

// NewListClustersParams indicates an expected call of NewListClustersParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewListClustersParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListClustersParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewListClustersParams))
}

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

// NewListDedicatedClustersParams indicates an expected call of NewListDedicatedClustersParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewListDedicatedClustersParams() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewListDedicatedClustersParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewListDedicatedClustersParams))
}

// NewReleaseDedicatedClusterParams mocks base method.
func (m *MockClusterServiceIface) NewReleaseDedicatedClusterParams(clusterid string) *ReleaseDedicatedClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReleaseDedicatedClusterParams", clusterid)
	ret0, _ := ret[0].(*ReleaseDedicatedClusterParams)
	return ret0
}

// NewReleaseDedicatedClusterParams indicates an expected call of NewReleaseDedicatedClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewReleaseDedicatedClusterParams(clusterid interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReleaseDedicatedClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewReleaseDedicatedClusterParams), clusterid)
}

// NewUpdateClusterParams mocks base method.
func (m *MockClusterServiceIface) NewUpdateClusterParams(id string) *UpdateClusterParams {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewUpdateClusterParams", id)
	ret0, _ := ret[0].(*UpdateClusterParams)
	return ret0
}

// NewUpdateClusterParams indicates an expected call of NewUpdateClusterParams.
func (mr *MockClusterServiceIfaceMockRecorder) NewUpdateClusterParams(id interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateClusterParams", reflect.TypeOf((*MockClusterServiceIface)(nil).NewUpdateClusterParams), id)
}

// ReleaseDedicatedCluster mocks base method.
func (m *MockClusterServiceIface) ReleaseDedicatedCluster(p *ReleaseDedicatedClusterParams) (*ReleaseDedicatedClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReleaseDedicatedCluster", p)
	ret0, _ := ret[0].(*ReleaseDedicatedClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReleaseDedicatedCluster indicates an expected call of ReleaseDedicatedCluster.
func (mr *MockClusterServiceIfaceMockRecorder) ReleaseDedicatedCluster(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseDedicatedCluster", reflect.TypeOf((*MockClusterServiceIface)(nil).ReleaseDedicatedCluster), p)
}

// UpdateCluster mocks base method.
func (m *MockClusterServiceIface) UpdateCluster(p *UpdateClusterParams) (*UpdateClusterResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateCluster", p)
	ret0, _ := ret[0].(*UpdateClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateCluster indicates an expected call of UpdateCluster.
func (mr *MockClusterServiceIfaceMockRecorder) UpdateCluster(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCluster", reflect.TypeOf((*MockClusterServiceIface)(nil).UpdateCluster), p)
}