github.com/m3db/m3@v1.5.0/src/cluster/placement/placement_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/cluster/placement/types.go

// Copyright (c) 2021 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

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

import (
	"reflect"
	"time"

	"github.com/m3db/m3/src/cluster/generated/proto/placementpb"
	"github.com/m3db/m3/src/cluster/kv"
	"github.com/m3db/m3/src/cluster/shard"
	"github.com/m3db/m3/src/x/clock"
	"github.com/m3db/m3/src/x/instrument"

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

// MockInstance is a mock of Instance interface.
type MockInstance struct {
	ctrl     *gomock.Controller
	recorder *MockInstanceMockRecorder
}

// MockInstanceMockRecorder is the mock recorder for MockInstance.
type MockInstanceMockRecorder struct {
	mock *MockInstance
}

// NewMockInstance creates a new mock instance.
func NewMockInstance(ctrl *gomock.Controller) *MockInstance {
	mock := &MockInstance{ctrl: ctrl}
	mock.recorder = &MockInstanceMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Proto mocks base method.
func (m *MockInstance) Proto() (*placementpb.Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proto")
	ret0, _ := ret[0].(*placementpb.Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetEndpoint mocks base method.
func (m *MockInstance) SetEndpoint(ip string) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetEndpoint", ip)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetEndpoint indicates an expected call of SetEndpoint.
func (mr *MockInstanceMockRecorder) SetEndpoint(ip interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEndpoint", reflect.TypeOf((*MockInstance)(nil).SetEndpoint), ip)
}

// SetHostname mocks base method.
func (m *MockInstance) SetHostname(value string) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetHostname", value)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetHostname indicates an expected call of SetHostname.
func (mr *MockInstanceMockRecorder) SetHostname(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetHostname", reflect.TypeOf((*MockInstance)(nil).SetHostname), value)
}

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

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

// SetIsolationGroup mocks base method.
func (m *MockInstance) SetIsolationGroup(r string) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIsolationGroup", r)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetIsolationGroup indicates an expected call of SetIsolationGroup.
func (mr *MockInstanceMockRecorder) SetIsolationGroup(r interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsolationGroup", reflect.TypeOf((*MockInstance)(nil).SetIsolationGroup), r)
}

// SetMetadata mocks base method.
func (m *MockInstance) SetMetadata(value InstanceMetadata) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMetadata", value)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetMetadata indicates an expected call of SetMetadata.
func (mr *MockInstanceMockRecorder) SetMetadata(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMetadata", reflect.TypeOf((*MockInstance)(nil).SetMetadata), value)
}

// SetPort mocks base method.
func (m *MockInstance) SetPort(value uint32) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPort", value)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetPort indicates an expected call of SetPort.
func (mr *MockInstanceMockRecorder) SetPort(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPort", reflect.TypeOf((*MockInstance)(nil).SetPort), value)
}

// SetShardSetID mocks base method.
func (m *MockInstance) SetShardSetID(value uint32) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetShardSetID", value)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetShardSetID indicates an expected call of SetShardSetID.
func (mr *MockInstanceMockRecorder) SetShardSetID(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShardSetID", reflect.TypeOf((*MockInstance)(nil).SetShardSetID), value)
}

// SetShards mocks base method.
func (m *MockInstance) SetShards(s shard.Shards) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetShards", s)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetShards indicates an expected call of SetShards.
func (mr *MockInstanceMockRecorder) SetShards(s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShards", reflect.TypeOf((*MockInstance)(nil).SetShards), s)
}

// SetWeight mocks base method.
func (m *MockInstance) SetWeight(w uint32) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetWeight", w)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetWeight indicates an expected call of SetWeight.
func (mr *MockInstanceMockRecorder) SetWeight(w interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWeight", reflect.TypeOf((*MockInstance)(nil).SetWeight), w)
}

// SetZone mocks base method.
func (m *MockInstance) SetZone(z string) Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetZone", z)
	ret0, _ := ret[0].(Instance)
	return ret0
}

// SetZone indicates an expected call of SetZone.
func (mr *MockInstanceMockRecorder) SetZone(z interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetZone", reflect.TypeOf((*MockInstance)(nil).SetZone), z)
}

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

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

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

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

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

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

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

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

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

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

// MockPlacement is a mock of Placement interface.
type MockPlacement struct {
	ctrl     *gomock.Controller
	recorder *MockPlacementMockRecorder
}

// MockPlacementMockRecorder is the mock recorder for MockPlacement.
type MockPlacementMockRecorder struct {
	mock *MockPlacement
}

// NewMockPlacement creates a new mock instance.
func NewMockPlacement(ctrl *gomock.Controller) *MockPlacement {
	mock := &MockPlacement{ctrl: ctrl}
	mock.recorder = &MockPlacementMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Instance mocks base method.
func (m *MockPlacement) Instance(id string) (Instance, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Instance", id)
	ret0, _ := ret[0].(Instance)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

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

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

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

// InstancesForShard mocks base method.
func (m *MockPlacement) InstancesForShard(shard uint32) []Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstancesForShard", shard)
	ret0, _ := ret[0].([]Instance)
	return ret0
}

// InstancesForShard indicates an expected call of InstancesForShard.
func (mr *MockPlacementMockRecorder) InstancesForShard(shard interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstancesForShard", reflect.TypeOf((*MockPlacement)(nil).InstancesForShard), shard)
}

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

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

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

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

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

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

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

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

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

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

// Proto mocks base method.
func (m *MockPlacement) Proto() (*placementpb.Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proto")
	ret0, _ := ret[0].(*placementpb.Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SetCutoverNanos mocks base method.
func (m *MockPlacement) SetCutoverNanos(cutoverNanos int64) Placement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCutoverNanos", cutoverNanos)
	ret0, _ := ret[0].(Placement)
	return ret0
}

// SetCutoverNanos indicates an expected call of SetCutoverNanos.
func (mr *MockPlacementMockRecorder) SetCutoverNanos(cutoverNanos interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCutoverNanos", reflect.TypeOf((*MockPlacement)(nil).SetCutoverNanos), cutoverNanos)
}

// SetInstances mocks base method.
func (m *MockPlacement) SetInstances(instances []Instance) Placement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInstances", instances)
	ret0, _ := ret[0].(Placement)
	return ret0
}

// SetInstances indicates an expected call of SetInstances.
func (mr *MockPlacementMockRecorder) SetInstances(instances interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstances", reflect.TypeOf((*MockPlacement)(nil).SetInstances), instances)
}

// SetIsMirrored mocks base method.
func (m *MockPlacement) SetIsMirrored(v bool) Placement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIsMirrored", v)
	ret0, _ := ret[0].(Placement)
	return ret0
}

// SetIsMirrored indicates an expected call of SetIsMirrored.
func (mr *MockPlacementMockRecorder) SetIsMirrored(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsMirrored", reflect.TypeOf((*MockPlacement)(nil).SetIsMirrored), v)
}

// SetIsSharded mocks base method.
func (m *MockPlacement) SetIsSharded(v bool) Placement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIsSharded", v)
	ret0, _ := ret[0].(Placement)
	return ret0
}

// SetIsSharded indicates an expected call of SetIsSharded.
func (mr *MockPlacementMockRecorder) SetIsSharded(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsSharded", reflect.TypeOf((*MockPlacement)(nil).SetIsSharded), v)
}

// SetMaxShardSetID mocks base method.
func (m *MockPlacement) SetMaxShardSetID(value uint32) Placement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMaxShardSetID", value)
	ret0, _ := ret[0].(Placement)
	return ret0
}

// SetMaxShardSetID indicates an expected call of SetMaxShardSetID.
func (mr *MockPlacementMockRecorder) SetMaxShardSetID(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxShardSetID", reflect.TypeOf((*MockPlacement)(nil).SetMaxShardSetID), value)
}

// SetReplicaFactor mocks base method.
func (m *MockPlacement) SetReplicaFactor(rf int) Placement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetReplicaFactor", rf)
	ret0, _ := ret[0].(Placement)
	return ret0
}

// SetReplicaFactor indicates an expected call of SetReplicaFactor.
func (mr *MockPlacementMockRecorder) SetReplicaFactor(rf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReplicaFactor", reflect.TypeOf((*MockPlacement)(nil).SetReplicaFactor), rf)
}

// SetShards mocks base method.
func (m *MockPlacement) SetShards(s []uint32) Placement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetShards", s)
	ret0, _ := ret[0].(Placement)
	return ret0
}

// SetShards indicates an expected call of SetShards.
func (mr *MockPlacementMockRecorder) SetShards(s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShards", reflect.TypeOf((*MockPlacement)(nil).SetShards), s)
}

// SetVersion mocks base method.
func (m *MockPlacement) SetVersion(v int) Placement {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetVersion", v)
	ret0, _ := ret[0].(Placement)
	return ret0
}

// SetVersion indicates an expected call of SetVersion.
func (mr *MockPlacementMockRecorder) SetVersion(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetVersion", reflect.TypeOf((*MockPlacement)(nil).SetVersion), v)
}

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

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

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

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

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

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

// MockWatch is a mock of Watch interface.
type MockWatch struct {
	ctrl     *gomock.Controller
	recorder *MockWatchMockRecorder
}

// MockWatchMockRecorder is the mock recorder for MockWatch.
type MockWatchMockRecorder struct {
	mock *MockWatch
}

// NewMockWatch creates a new mock instance.
func NewMockWatch(ctrl *gomock.Controller) *MockWatch {
	mock := &MockWatch{ctrl: ctrl}
	mock.recorder = &MockWatchMockRecorder{mock}
	return mock
}

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

// C mocks base method.
func (m *MockWatch) C() <-chan struct{} {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "C")
	ret0, _ := ret[0].(<-chan struct{})
	return ret0
}

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

// Close mocks base method.
func (m *MockWatch) Close() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Close")
}

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

// Get mocks base method.
func (m *MockWatch) Get() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MockWatcher is a mock of Watcher interface.
type MockWatcher struct {
	ctrl     *gomock.Controller
	recorder *MockWatcherMockRecorder
}

// MockWatcherMockRecorder is the mock recorder for MockWatcher.
type MockWatcherMockRecorder struct {
	mock *MockWatcher
}

// NewMockWatcher creates a new mock instance.
func NewMockWatcher(ctrl *gomock.Controller) *MockWatcher {
	mock := &MockWatcher{ctrl: ctrl}
	mock.recorder = &MockWatcherMockRecorder{mock}
	return mock
}

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

// Get mocks base method.
func (m *MockWatcher) Get() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// MockWatcherOptions is a mock of WatcherOptions interface.
type MockWatcherOptions struct {
	ctrl     *gomock.Controller
	recorder *MockWatcherOptionsMockRecorder
}

// MockWatcherOptionsMockRecorder is the mock recorder for MockWatcherOptions.
type MockWatcherOptionsMockRecorder struct {
	mock *MockWatcherOptions
}

// NewMockWatcherOptions creates a new mock instance.
func NewMockWatcherOptions(ctrl *gomock.Controller) *MockWatcherOptions {
	mock := &MockWatcherOptions{ctrl: ctrl}
	mock.recorder = &MockWatcherOptionsMockRecorder{mock}
	return mock
}

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

// InitWatchTimeout mocks base method.
func (m *MockWatcherOptions) InitWatchTimeout() time.Duration {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitWatchTimeout")
	ret0, _ := ret[0].(time.Duration)
	return ret0
}

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

// InstrumentOptions mocks base method.
func (m *MockWatcherOptions) InstrumentOptions() instrument.Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstrumentOptions")
	ret0, _ := ret[0].(instrument.Options)
	return ret0
}

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

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

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

// SetInitWatchTimeout mocks base method.
func (m *MockWatcherOptions) SetInitWatchTimeout(value time.Duration) WatcherOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInitWatchTimeout", value)
	ret0, _ := ret[0].(WatcherOptions)
	return ret0
}

// SetInitWatchTimeout indicates an expected call of SetInitWatchTimeout.
func (mr *MockWatcherOptionsMockRecorder) SetInitWatchTimeout(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInitWatchTimeout", reflect.TypeOf((*MockWatcherOptions)(nil).SetInitWatchTimeout), value)
}

// SetInstrumentOptions mocks base method.
func (m *MockWatcherOptions) SetInstrumentOptions(value instrument.Options) WatcherOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInstrumentOptions", value)
	ret0, _ := ret[0].(WatcherOptions)
	return ret0
}

// SetInstrumentOptions indicates an expected call of SetInstrumentOptions.
func (mr *MockWatcherOptionsMockRecorder) SetInstrumentOptions(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstrumentOptions", reflect.TypeOf((*MockWatcherOptions)(nil).SetInstrumentOptions), value)
}

// SetOnPlacementChangedFn mocks base method.
func (m *MockWatcherOptions) SetOnPlacementChangedFn(value OnPlacementChangedFn) WatcherOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOnPlacementChangedFn", value)
	ret0, _ := ret[0].(WatcherOptions)
	return ret0
}

// SetOnPlacementChangedFn indicates an expected call of SetOnPlacementChangedFn.
func (mr *MockWatcherOptionsMockRecorder) SetOnPlacementChangedFn(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetOnPlacementChangedFn", reflect.TypeOf((*MockWatcherOptions)(nil).SetOnPlacementChangedFn), value)
}

// SetStagedPlacementKey mocks base method.
func (m *MockWatcherOptions) SetStagedPlacementKey(value string) WatcherOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetStagedPlacementKey", value)
	ret0, _ := ret[0].(WatcherOptions)
	return ret0
}

// SetStagedPlacementKey indicates an expected call of SetStagedPlacementKey.
func (mr *MockWatcherOptionsMockRecorder) SetStagedPlacementKey(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStagedPlacementKey", reflect.TypeOf((*MockWatcherOptions)(nil).SetStagedPlacementKey), value)
}

// SetStagedPlacementStore mocks base method.
func (m *MockWatcherOptions) SetStagedPlacementStore(store kv.Store) WatcherOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetStagedPlacementStore", store)
	ret0, _ := ret[0].(WatcherOptions)
	return ret0
}

// SetStagedPlacementStore indicates an expected call of SetStagedPlacementStore.
func (mr *MockWatcherOptionsMockRecorder) SetStagedPlacementStore(store interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetStagedPlacementStore", reflect.TypeOf((*MockWatcherOptions)(nil).SetStagedPlacementStore), store)
}

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

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

// StagedPlacementStore mocks base method.
func (m *MockWatcherOptions) StagedPlacementStore() kv.Store {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StagedPlacementStore")
	ret0, _ := ret[0].(kv.Store)
	return ret0
}

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

// MockOptions is a mock of Options interface.
type MockOptions struct {
	ctrl     *gomock.Controller
	recorder *MockOptionsMockRecorder
}

// MockOptionsMockRecorder is the mock recorder for MockOptions.
type MockOptionsMockRecorder struct {
	mock *MockOptions
}

// NewMockOptions creates a new mock instance.
func NewMockOptions(ctrl *gomock.Controller) *MockOptions {
	mock := &MockOptions{ctrl: ctrl}
	mock.recorder = &MockOptionsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// InstrumentOptions mocks base method.
func (m *MockOptions) InstrumentOptions() instrument.Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InstrumentOptions")
	ret0, _ := ret[0].(instrument.Options)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetAddAllCandidates mocks base method.
func (m *MockOptions) SetAddAllCandidates(addAllCandidates bool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAddAllCandidates", addAllCandidates)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetAddAllCandidates indicates an expected call of SetAddAllCandidates.
func (mr *MockOptionsMockRecorder) SetAddAllCandidates(addAllCandidates interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAddAllCandidates", reflect.TypeOf((*MockOptions)(nil).SetAddAllCandidates), addAllCandidates)
}

// SetAllowAllZones mocks base method.
func (m *MockOptions) SetAllowAllZones(allowAllZones bool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAllowAllZones", allowAllZones)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetAllowAllZones indicates an expected call of SetAllowAllZones.
func (mr *MockOptionsMockRecorder) SetAllowAllZones(allowAllZones interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowAllZones", reflect.TypeOf((*MockOptions)(nil).SetAllowAllZones), allowAllZones)
}

// SetAllowPartialReplace mocks base method.
func (m *MockOptions) SetAllowPartialReplace(allowPartialReplace bool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAllowPartialReplace", allowPartialReplace)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetAllowPartialReplace indicates an expected call of SetAllowPartialReplace.
func (mr *MockOptionsMockRecorder) SetAllowPartialReplace(allowPartialReplace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetAllowPartialReplace", reflect.TypeOf((*MockOptions)(nil).SetAllowPartialReplace), allowPartialReplace)
}

// SetCompress mocks base method.
func (m *MockOptions) SetCompress(v bool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetCompress", v)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetCompress indicates an expected call of SetCompress.
func (mr *MockOptionsMockRecorder) SetCompress(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCompress", reflect.TypeOf((*MockOptions)(nil).SetCompress), v)
}

// SetDryrun mocks base method.
func (m *MockOptions) SetDryrun(d bool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetDryrun", d)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetDryrun indicates an expected call of SetDryrun.
func (mr *MockOptionsMockRecorder) SetDryrun(d interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDryrun", reflect.TypeOf((*MockOptions)(nil).SetDryrun), d)
}

// SetInstanceSelector mocks base method.
func (m *MockOptions) SetInstanceSelector(s InstanceSelector) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInstanceSelector", s)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetInstanceSelector indicates an expected call of SetInstanceSelector.
func (mr *MockOptionsMockRecorder) SetInstanceSelector(s interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstanceSelector", reflect.TypeOf((*MockOptions)(nil).SetInstanceSelector), s)
}

// SetInstrumentOptions mocks base method.
func (m *MockOptions) SetInstrumentOptions(iopts instrument.Options) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetInstrumentOptions", iopts)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetInstrumentOptions indicates an expected call of SetInstrumentOptions.
func (mr *MockOptionsMockRecorder) SetInstrumentOptions(iopts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetInstrumentOptions", reflect.TypeOf((*MockOptions)(nil).SetInstrumentOptions), iopts)
}

// SetIsMirrored mocks base method.
func (m_2 *MockOptions) SetIsMirrored(m bool) Options {
	m_2.ctrl.T.Helper()
	ret := m_2.ctrl.Call(m_2, "SetIsMirrored", m)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetIsMirrored indicates an expected call of SetIsMirrored.
func (mr *MockOptionsMockRecorder) SetIsMirrored(m interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsMirrored", reflect.TypeOf((*MockOptions)(nil).SetIsMirrored), m)
}

// SetIsShardCutoffFn mocks base method.
func (m *MockOptions) SetIsShardCutoffFn(fn ShardValidateFn) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIsShardCutoffFn", fn)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetIsShardCutoffFn indicates an expected call of SetIsShardCutoffFn.
func (mr *MockOptionsMockRecorder) SetIsShardCutoffFn(fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsShardCutoffFn", reflect.TypeOf((*MockOptions)(nil).SetIsShardCutoffFn), fn)
}

// SetIsShardCutoverFn mocks base method.
func (m *MockOptions) SetIsShardCutoverFn(fn ShardValidateFn) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIsShardCutoverFn", fn)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetIsShardCutoverFn indicates an expected call of SetIsShardCutoverFn.
func (mr *MockOptionsMockRecorder) SetIsShardCutoverFn(fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsShardCutoverFn", reflect.TypeOf((*MockOptions)(nil).SetIsShardCutoverFn), fn)
}

// SetIsSharded mocks base method.
func (m *MockOptions) SetIsSharded(sharded bool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIsSharded", sharded)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetIsSharded indicates an expected call of SetIsSharded.
func (mr *MockOptionsMockRecorder) SetIsSharded(sharded interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsSharded", reflect.TypeOf((*MockOptions)(nil).SetIsSharded), sharded)
}

// SetIsStaged mocks base method.
func (m *MockOptions) SetIsStaged(v bool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetIsStaged", v)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetIsStaged indicates an expected call of SetIsStaged.
func (mr *MockOptionsMockRecorder) SetIsStaged(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetIsStaged", reflect.TypeOf((*MockOptions)(nil).SetIsStaged), v)
}

// SetNowFn mocks base method.
func (m *MockOptions) SetNowFn(fn clock.NowFn) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNowFn", fn)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetNowFn indicates an expected call of SetNowFn.
func (mr *MockOptionsMockRecorder) SetNowFn(fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNowFn", reflect.TypeOf((*MockOptions)(nil).SetNowFn), fn)
}

// SetPlacementCutoverNanosFn mocks base method.
func (m *MockOptions) SetPlacementCutoverNanosFn(fn TimeNanosFn) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetPlacementCutoverNanosFn", fn)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetPlacementCutoverNanosFn indicates an expected call of SetPlacementCutoverNanosFn.
func (mr *MockOptionsMockRecorder) SetPlacementCutoverNanosFn(fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetPlacementCutoverNanosFn", reflect.TypeOf((*MockOptions)(nil).SetPlacementCutoverNanosFn), fn)
}

// SetShardCutoffNanosFn mocks base method.
func (m *MockOptions) SetShardCutoffNanosFn(fn TimeNanosFn) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetShardCutoffNanosFn", fn)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetShardCutoffNanosFn indicates an expected call of SetShardCutoffNanosFn.
func (mr *MockOptionsMockRecorder) SetShardCutoffNanosFn(fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShardCutoffNanosFn", reflect.TypeOf((*MockOptions)(nil).SetShardCutoffNanosFn), fn)
}

// SetShardCutoverNanosFn mocks base method.
func (m *MockOptions) SetShardCutoverNanosFn(fn TimeNanosFn) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetShardCutoverNanosFn", fn)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetShardCutoverNanosFn indicates an expected call of SetShardCutoverNanosFn.
func (mr *MockOptionsMockRecorder) SetShardCutoverNanosFn(fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShardCutoverNanosFn", reflect.TypeOf((*MockOptions)(nil).SetShardCutoverNanosFn), fn)
}

// SetShardStateMode mocks base method.
func (m *MockOptions) SetShardStateMode(value ShardStateMode) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetShardStateMode", value)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetShardStateMode indicates an expected call of SetShardStateMode.
func (mr *MockOptionsMockRecorder) SetShardStateMode(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetShardStateMode", reflect.TypeOf((*MockOptions)(nil).SetShardStateMode), value)
}

// SetSkipPortMirroring mocks base method.
func (m *MockOptions) SetSkipPortMirroring(v bool) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSkipPortMirroring", v)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetSkipPortMirroring indicates an expected call of SetSkipPortMirroring.
func (mr *MockOptionsMockRecorder) SetSkipPortMirroring(v interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSkipPortMirroring", reflect.TypeOf((*MockOptions)(nil).SetSkipPortMirroring), v)
}

// SetValidZone mocks base method.
func (m *MockOptions) SetValidZone(z string) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidZone", z)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetValidZone indicates an expected call of SetValidZone.
func (mr *MockOptionsMockRecorder) SetValidZone(z interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidZone", reflect.TypeOf((*MockOptions)(nil).SetValidZone), z)
}

// SetValidateFnBeforeUpdate mocks base method.
func (m *MockOptions) SetValidateFnBeforeUpdate(fn ValidateFn) Options {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetValidateFnBeforeUpdate", fn)
	ret0, _ := ret[0].(Options)
	return ret0
}

// SetValidateFnBeforeUpdate indicates an expected call of SetValidateFnBeforeUpdate.
func (mr *MockOptionsMockRecorder) SetValidateFnBeforeUpdate(fn interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetValidateFnBeforeUpdate", reflect.TypeOf((*MockOptions)(nil).SetValidateFnBeforeUpdate), fn)
}

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

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

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

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

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

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

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

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

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

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

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

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

// MockStorage is a mock of Storage interface.
type MockStorage struct {
	ctrl     *gomock.Controller
	recorder *MockStorageMockRecorder
}

// MockStorageMockRecorder is the mock recorder for MockStorage.
type MockStorageMockRecorder struct {
	mock *MockStorage
}

// NewMockStorage creates a new mock instance.
func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
	mock := &MockStorage{ctrl: ctrl}
	mock.recorder = &MockStorageMockRecorder{mock}
	return mock
}

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

// CheckAndSet mocks base method.
func (m *MockStorage) CheckAndSet(p Placement, version int) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAndSet", p, version)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckAndSetProto mocks base method.
func (m *MockStorage) CheckAndSetProto(p proto.Message, version int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAndSetProto", p, version)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// PlacementForVersion mocks base method.
func (m *MockStorage) PlacementForVersion(version int) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PlacementForVersion", version)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PlacementForVersion indicates an expected call of PlacementForVersion.
func (mr *MockStorageMockRecorder) PlacementForVersion(version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PlacementForVersion", reflect.TypeOf((*MockStorage)(nil).PlacementForVersion), version)
}

// Proto mocks base method.
func (m *MockStorage) Proto() (proto.Message, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proto")
	ret0, _ := ret[0].(proto.Message)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

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

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

// SetProto mocks base method.
func (m *MockStorage) SetProto(p proto.Message) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetProto", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockService is a mock of Service interface.
type MockService struct {
	ctrl     *gomock.Controller
	recorder *MockServiceMockRecorder
}

// MockServiceMockRecorder is the mock recorder for MockService.
type MockServiceMockRecorder struct {
	mock *MockService
}

// NewMockService creates a new mock instance.
func NewMockService(ctrl *gomock.Controller) *MockService {
	mock := &MockService{ctrl: ctrl}
	mock.recorder = &MockServiceMockRecorder{mock}
	return mock
}

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

// AddInstances mocks base method.
func (m *MockService) AddInstances(candidates []Instance) (Placement, []Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddInstances", candidates)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].([]Instance)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddInstances indicates an expected call of AddInstances.
func (mr *MockServiceMockRecorder) AddInstances(candidates interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddInstances", reflect.TypeOf((*MockService)(nil).AddInstances), candidates)
}

// AddReplica mocks base method.
func (m *MockService) AddReplica() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddReplica")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BalanceShards mocks base method.
func (m *MockService) BalanceShards() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BalanceShards")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BuildInitialPlacement mocks base method.
func (m *MockService) BuildInitialPlacement(instances []Instance, numShards, rf int) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildInitialPlacement", instances, numShards, rf)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildInitialPlacement indicates an expected call of BuildInitialPlacement.
func (mr *MockServiceMockRecorder) BuildInitialPlacement(instances, numShards, rf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildInitialPlacement", reflect.TypeOf((*MockService)(nil).BuildInitialPlacement), instances, numShards, rf)
}

// CheckAndSet mocks base method.
func (m *MockService) CheckAndSet(p Placement, version int) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAndSet", p, version)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CheckAndSetProto mocks base method.
func (m *MockService) CheckAndSetProto(p proto.Message, version int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CheckAndSetProto", p, version)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MarkAllShardsAvailable mocks base method.
func (m *MockService) MarkAllShardsAvailable() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkAllShardsAvailable")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MarkInstanceAvailable mocks base method.
func (m *MockService) MarkInstanceAvailable(instanceID string) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkInstanceAvailable", instanceID)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarkInstanceAvailable indicates an expected call of MarkInstanceAvailable.
func (mr *MockServiceMockRecorder) MarkInstanceAvailable(instanceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkInstanceAvailable", reflect.TypeOf((*MockService)(nil).MarkInstanceAvailable), instanceID)
}

// MarkShardsAvailable mocks base method.
func (m *MockService) MarkShardsAvailable(instanceID string, shardIDs ...uint32) (Placement, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{instanceID}
	for _, a := range shardIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MarkShardsAvailable", varargs...)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarkShardsAvailable indicates an expected call of MarkShardsAvailable.
func (mr *MockServiceMockRecorder) MarkShardsAvailable(instanceID interface{}, shardIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{instanceID}, shardIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkShardsAvailable", reflect.TypeOf((*MockService)(nil).MarkShardsAvailable), varargs...)
}

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

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

// PlacementForVersion mocks base method.
func (m *MockService) PlacementForVersion(version int) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PlacementForVersion", version)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PlacementForVersion indicates an expected call of PlacementForVersion.
func (mr *MockServiceMockRecorder) PlacementForVersion(version interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PlacementForVersion", reflect.TypeOf((*MockService)(nil).PlacementForVersion), version)
}

// Proto mocks base method.
func (m *MockService) Proto() (proto.Message, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Proto")
	ret0, _ := ret[0].(proto.Message)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// RemoveInstances mocks base method.
func (m *MockService) RemoveInstances(leavingInstanceIDs []string) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveInstances", leavingInstanceIDs)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveInstances indicates an expected call of RemoveInstances.
func (mr *MockServiceMockRecorder) RemoveInstances(leavingInstanceIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveInstances", reflect.TypeOf((*MockService)(nil).RemoveInstances), leavingInstanceIDs)
}

// ReplaceInstances mocks base method.
func (m *MockService) ReplaceInstances(leavingInstanceIDs []string, candidates []Instance) (Placement, []Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceInstances", leavingInstanceIDs, candidates)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].([]Instance)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReplaceInstances indicates an expected call of ReplaceInstances.
func (mr *MockServiceMockRecorder) ReplaceInstances(leavingInstanceIDs, candidates interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceInstances", reflect.TypeOf((*MockService)(nil).ReplaceInstances), leavingInstanceIDs, candidates)
}

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

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

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

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

// SetProto mocks base method.
func (m *MockService) SetProto(p proto.Message) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetProto", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// MockOperator is a mock of Operator interface.
type MockOperator struct {
	ctrl     *gomock.Controller
	recorder *MockOperatorMockRecorder
}

// MockOperatorMockRecorder is the mock recorder for MockOperator.
type MockOperatorMockRecorder struct {
	mock *MockOperator
}

// NewMockOperator creates a new mock instance.
func NewMockOperator(ctrl *gomock.Controller) *MockOperator {
	mock := &MockOperator{ctrl: ctrl}
	mock.recorder = &MockOperatorMockRecorder{mock}
	return mock
}

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

// AddInstances mocks base method.
func (m *MockOperator) AddInstances(candidates []Instance) (Placement, []Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddInstances", candidates)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].([]Instance)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddInstances indicates an expected call of AddInstances.
func (mr *MockOperatorMockRecorder) AddInstances(candidates interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddInstances", reflect.TypeOf((*MockOperator)(nil).AddInstances), candidates)
}

// AddReplica mocks base method.
func (m *MockOperator) AddReplica() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddReplica")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BalanceShards mocks base method.
func (m *MockOperator) BalanceShards() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BalanceShards")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BuildInitialPlacement mocks base method.
func (m *MockOperator) BuildInitialPlacement(instances []Instance, numShards, rf int) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildInitialPlacement", instances, numShards, rf)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildInitialPlacement indicates an expected call of BuildInitialPlacement.
func (mr *MockOperatorMockRecorder) BuildInitialPlacement(instances, numShards, rf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildInitialPlacement", reflect.TypeOf((*MockOperator)(nil).BuildInitialPlacement), instances, numShards, rf)
}

// MarkAllShardsAvailable mocks base method.
func (m *MockOperator) MarkAllShardsAvailable() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkAllShardsAvailable")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MarkInstanceAvailable mocks base method.
func (m *MockOperator) MarkInstanceAvailable(instanceID string) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkInstanceAvailable", instanceID)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarkInstanceAvailable indicates an expected call of MarkInstanceAvailable.
func (mr *MockOperatorMockRecorder) MarkInstanceAvailable(instanceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkInstanceAvailable", reflect.TypeOf((*MockOperator)(nil).MarkInstanceAvailable), instanceID)
}

// MarkShardsAvailable mocks base method.
func (m *MockOperator) MarkShardsAvailable(instanceID string, shardIDs ...uint32) (Placement, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{instanceID}
	for _, a := range shardIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MarkShardsAvailable", varargs...)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarkShardsAvailable indicates an expected call of MarkShardsAvailable.
func (mr *MockOperatorMockRecorder) MarkShardsAvailable(instanceID interface{}, shardIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{instanceID}, shardIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkShardsAvailable", reflect.TypeOf((*MockOperator)(nil).MarkShardsAvailable), varargs...)
}

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

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

// RemoveInstances mocks base method.
func (m *MockOperator) RemoveInstances(leavingInstanceIDs []string) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveInstances", leavingInstanceIDs)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveInstances indicates an expected call of RemoveInstances.
func (mr *MockOperatorMockRecorder) RemoveInstances(leavingInstanceIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveInstances", reflect.TypeOf((*MockOperator)(nil).RemoveInstances), leavingInstanceIDs)
}

// ReplaceInstances mocks base method.
func (m *MockOperator) ReplaceInstances(leavingInstanceIDs []string, candidates []Instance) (Placement, []Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceInstances", leavingInstanceIDs, candidates)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].([]Instance)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReplaceInstances indicates an expected call of ReplaceInstances.
func (mr *MockOperatorMockRecorder) ReplaceInstances(leavingInstanceIDs, candidates interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceInstances", reflect.TypeOf((*MockOperator)(nil).ReplaceInstances), leavingInstanceIDs, candidates)
}

// Mockoperations is a mock of operations interface.
type Mockoperations struct {
	ctrl     *gomock.Controller
	recorder *MockoperationsMockRecorder
}

// MockoperationsMockRecorder is the mock recorder for Mockoperations.
type MockoperationsMockRecorder struct {
	mock *Mockoperations
}

// NewMockoperations creates a new mock instance.
func NewMockoperations(ctrl *gomock.Controller) *Mockoperations {
	mock := &Mockoperations{ctrl: ctrl}
	mock.recorder = &MockoperationsMockRecorder{mock}
	return mock
}

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

// AddInstances mocks base method.
func (m *Mockoperations) AddInstances(candidates []Instance) (Placement, []Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddInstances", candidates)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].([]Instance)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddInstances indicates an expected call of AddInstances.
func (mr *MockoperationsMockRecorder) AddInstances(candidates interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddInstances", reflect.TypeOf((*Mockoperations)(nil).AddInstances), candidates)
}

// AddReplica mocks base method.
func (m *Mockoperations) AddReplica() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddReplica")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BalanceShards mocks base method.
func (m *Mockoperations) BalanceShards() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BalanceShards")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BuildInitialPlacement mocks base method.
func (m *Mockoperations) BuildInitialPlacement(instances []Instance, numShards, rf int) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BuildInitialPlacement", instances, numShards, rf)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildInitialPlacement indicates an expected call of BuildInitialPlacement.
func (mr *MockoperationsMockRecorder) BuildInitialPlacement(instances, numShards, rf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildInitialPlacement", reflect.TypeOf((*Mockoperations)(nil).BuildInitialPlacement), instances, numShards, rf)
}

// MarkAllShardsAvailable mocks base method.
func (m *Mockoperations) MarkAllShardsAvailable() (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkAllShardsAvailable")
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MarkInstanceAvailable mocks base method.
func (m *Mockoperations) MarkInstanceAvailable(instanceID string) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkInstanceAvailable", instanceID)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarkInstanceAvailable indicates an expected call of MarkInstanceAvailable.
func (mr *MockoperationsMockRecorder) MarkInstanceAvailable(instanceID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkInstanceAvailable", reflect.TypeOf((*Mockoperations)(nil).MarkInstanceAvailable), instanceID)
}

// MarkShardsAvailable mocks base method.
func (m *Mockoperations) MarkShardsAvailable(instanceID string, shardIDs ...uint32) (Placement, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{instanceID}
	for _, a := range shardIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MarkShardsAvailable", varargs...)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarkShardsAvailable indicates an expected call of MarkShardsAvailable.
func (mr *MockoperationsMockRecorder) MarkShardsAvailable(instanceID interface{}, shardIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{instanceID}, shardIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkShardsAvailable", reflect.TypeOf((*Mockoperations)(nil).MarkShardsAvailable), varargs...)
}

// RemoveInstances mocks base method.
func (m *Mockoperations) RemoveInstances(leavingInstanceIDs []string) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveInstances", leavingInstanceIDs)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RemoveInstances indicates an expected call of RemoveInstances.
func (mr *MockoperationsMockRecorder) RemoveInstances(leavingInstanceIDs interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveInstances", reflect.TypeOf((*Mockoperations)(nil).RemoveInstances), leavingInstanceIDs)
}

// ReplaceInstances mocks base method.
func (m *Mockoperations) ReplaceInstances(leavingInstanceIDs []string, candidates []Instance) (Placement, []Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceInstances", leavingInstanceIDs, candidates)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].([]Instance)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// ReplaceInstances indicates an expected call of ReplaceInstances.
func (mr *MockoperationsMockRecorder) ReplaceInstances(leavingInstanceIDs, candidates interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceInstances", reflect.TypeOf((*Mockoperations)(nil).ReplaceInstances), leavingInstanceIDs, candidates)
}

// MockAlgorithm is a mock of Algorithm interface.
type MockAlgorithm struct {
	ctrl     *gomock.Controller
	recorder *MockAlgorithmMockRecorder
}

// MockAlgorithmMockRecorder is the mock recorder for MockAlgorithm.
type MockAlgorithmMockRecorder struct {
	mock *MockAlgorithm
}

// NewMockAlgorithm creates a new mock instance.
func NewMockAlgorithm(ctrl *gomock.Controller) *MockAlgorithm {
	mock := &MockAlgorithm{ctrl: ctrl}
	mock.recorder = &MockAlgorithmMockRecorder{mock}
	return mock
}

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

// AddInstances mocks base method.
func (m *MockAlgorithm) AddInstances(p Placement, instances []Instance) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddInstances", p, instances)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

// InitialPlacement mocks base method.
func (m *MockAlgorithm) InitialPlacement(instances []Instance, shards []uint32, rf int) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InitialPlacement", instances, shards, rf)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InitialPlacement indicates an expected call of InitialPlacement.
func (mr *MockAlgorithmMockRecorder) InitialPlacement(instances, shards, rf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InitialPlacement", reflect.TypeOf((*MockAlgorithm)(nil).InitialPlacement), instances, shards, rf)
}

// IsCompatibleWith mocks base method.
func (m *MockAlgorithm) IsCompatibleWith(p Placement) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsCompatibleWith", p)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MarkAllShardsAvailable mocks base method.
func (m *MockAlgorithm) MarkAllShardsAvailable(p Placement) (Placement, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MarkAllShardsAvailable", p)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// MarkShardsAvailable mocks base method.
func (m *MockAlgorithm) MarkShardsAvailable(p Placement, instanceID string, shardIDs ...uint32) (Placement, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{p, instanceID}
	for _, a := range shardIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "MarkShardsAvailable", varargs...)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MarkShardsAvailable indicates an expected call of MarkShardsAvailable.
func (mr *MockAlgorithmMockRecorder) MarkShardsAvailable(p, instanceID interface{}, shardIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{p, instanceID}, shardIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MarkShardsAvailable", reflect.TypeOf((*MockAlgorithm)(nil).MarkShardsAvailable), varargs...)
}

// RemoveInstances mocks base method.
func (m *MockAlgorithm) RemoveInstances(p Placement, leavingInstanceIDs []string) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveInstances", p, leavingInstanceIDs)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// ReplaceInstances mocks base method.
func (m *MockAlgorithm) ReplaceInstances(p Placement, leavingInstanecIDs []string, addingInstances []Instance) (Placement, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ReplaceInstances", p, leavingInstanecIDs, addingInstances)
	ret0, _ := ret[0].(Placement)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceInstances indicates an expected call of ReplaceInstances.
func (mr *MockAlgorithmMockRecorder) ReplaceInstances(p, leavingInstanecIDs, addingInstances interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceInstances", reflect.TypeOf((*MockAlgorithm)(nil).ReplaceInstances), p, leavingInstanecIDs, addingInstances)
}

// MockInstanceSelector is a mock of InstanceSelector interface.
type MockInstanceSelector struct {
	ctrl     *gomock.Controller
	recorder *MockInstanceSelectorMockRecorder
}

// MockInstanceSelectorMockRecorder is the mock recorder for MockInstanceSelector.
type MockInstanceSelectorMockRecorder struct {
	mock *MockInstanceSelector
}

// NewMockInstanceSelector creates a new mock instance.
func NewMockInstanceSelector(ctrl *gomock.Controller) *MockInstanceSelector {
	mock := &MockInstanceSelector{ctrl: ctrl}
	mock.recorder = &MockInstanceSelectorMockRecorder{mock}
	return mock
}

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

// SelectAddingInstances mocks base method.
func (m *MockInstanceSelector) SelectAddingInstances(candidates []Instance, p Placement) ([]Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectAddingInstances", candidates, p)
	ret0, _ := ret[0].([]Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SelectInitialInstances mocks base method.
func (m *MockInstanceSelector) SelectInitialInstances(candidates []Instance, rf int) ([]Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectInitialInstances", candidates, rf)
	ret0, _ := ret[0].([]Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectInitialInstances indicates an expected call of SelectInitialInstances.
func (mr *MockInstanceSelectorMockRecorder) SelectInitialInstances(candidates, rf interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectInitialInstances", reflect.TypeOf((*MockInstanceSelector)(nil).SelectInitialInstances), candidates, rf)
}

// SelectReplaceInstances mocks base method.
func (m *MockInstanceSelector) SelectReplaceInstances(candidates []Instance, leavingInstanceIDs []string, p Placement) ([]Instance, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SelectReplaceInstances", candidates, leavingInstanceIDs, p)
	ret0, _ := ret[0].([]Instance)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// SelectReplaceInstances indicates an expected call of SelectReplaceInstances.
func (mr *MockInstanceSelectorMockRecorder) SelectReplaceInstances(candidates, leavingInstanceIDs, p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectReplaceInstances", reflect.TypeOf((*MockInstanceSelector)(nil).SelectReplaceInstances), candidates, leavingInstanceIDs, p)
}

// MockDeploymentPlanner is a mock of DeploymentPlanner interface.
type MockDeploymentPlanner struct {
	ctrl     *gomock.Controller
	recorder *MockDeploymentPlannerMockRecorder
}

// MockDeploymentPlannerMockRecorder is the mock recorder for MockDeploymentPlanner.
type MockDeploymentPlannerMockRecorder struct {
	mock *MockDeploymentPlanner
}

// NewMockDeploymentPlanner creates a new mock instance.
func NewMockDeploymentPlanner(ctrl *gomock.Controller) *MockDeploymentPlanner {
	mock := &MockDeploymentPlanner{ctrl: ctrl}
	mock.recorder = &MockDeploymentPlannerMockRecorder{mock}
	return mock
}

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

// DeploymentSteps mocks base method.
func (m *MockDeploymentPlanner) DeploymentSteps(p Placement) [][]Instance {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeploymentSteps", p)
	ret0, _ := ret[0].([][]Instance)
	return ret0
}

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

// MockDeploymentOptions is a mock of DeploymentOptions interface.
type MockDeploymentOptions struct {
	ctrl     *gomock.Controller
	recorder *MockDeploymentOptionsMockRecorder
}

// MockDeploymentOptionsMockRecorder is the mock recorder for MockDeploymentOptions.
type MockDeploymentOptionsMockRecorder struct {
	mock *MockDeploymentOptions
}

// NewMockDeploymentOptions creates a new mock instance.
func NewMockDeploymentOptions(ctrl *gomock.Controller) *MockDeploymentOptions {
	mock := &MockDeploymentOptions{ctrl: ctrl}
	mock.recorder = &MockDeploymentOptionsMockRecorder{mock}
	return mock
}

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

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

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

// SetMaxStepSize mocks base method.
func (m *MockDeploymentOptions) SetMaxStepSize(stepSize int) DeploymentOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetMaxStepSize", stepSize)
	ret0, _ := ret[0].(DeploymentOptions)
	return ret0
}

// SetMaxStepSize indicates an expected call of SetMaxStepSize.
func (mr *MockDeploymentOptionsMockRecorder) SetMaxStepSize(stepSize interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetMaxStepSize", reflect.TypeOf((*MockDeploymentOptions)(nil).SetMaxStepSize), stepSize)
}