github.com/m3db/m3@v1.5.0/src/dbnode/namespace/namespace_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/dbnode/namespace/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 namespace is a generated GoMock package.
package namespace

import (
	"reflect"
	"time"

	"github.com/m3db/m3/src/cluster/client"
	"github.com/m3db/m3/src/dbnode/retention"
	"github.com/m3db/m3/src/x/ident"
	"github.com/m3db/m3/src/x/instrument"
	"github.com/m3db/m3/src/x/resource"

	"github.com/gogo/protobuf/types"
	"github.com/golang/mock/gomock"
)

// 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
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockIndexOptions is a mock of IndexOptions interface.
type MockIndexOptions struct {
	ctrl     *gomock.Controller
	recorder *MockIndexOptionsMockRecorder
}

// MockIndexOptionsMockRecorder is the mock recorder for MockIndexOptions.
type MockIndexOptionsMockRecorder struct {
	mock *MockIndexOptions
}

// NewMockIndexOptions creates a new mock instance.
func NewMockIndexOptions(ctrl *gomock.Controller) *MockIndexOptions {
	mock := &MockIndexOptions{ctrl: ctrl}
	mock.recorder = &MockIndexOptionsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockSchemaDescr is a mock of SchemaDescr interface.
type MockSchemaDescr struct {
	ctrl     *gomock.Controller
	recorder *MockSchemaDescrMockRecorder
}

// MockSchemaDescrMockRecorder is the mock recorder for MockSchemaDescr.
type MockSchemaDescrMockRecorder struct {
	mock *MockSchemaDescr
}

// NewMockSchemaDescr creates a new mock instance.
func NewMockSchemaDescr(ctrl *gomock.Controller) *MockSchemaDescr {
	mock := &MockSchemaDescr{ctrl: ctrl}
	mock.recorder = &MockSchemaDescrMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// String mocks base method.
func (m *MockSchemaDescr) 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 *MockSchemaDescrMockRecorder) String() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "String", reflect.TypeOf((*MockSchemaDescr)(nil).String))
}

// MockSchemaHistory is a mock of SchemaHistory interface.
type MockSchemaHistory struct {
	ctrl     *gomock.Controller
	recorder *MockSchemaHistoryMockRecorder
}

// MockSchemaHistoryMockRecorder is the mock recorder for MockSchemaHistory.
type MockSchemaHistoryMockRecorder struct {
	mock *MockSchemaHistory
}

// NewMockSchemaHistory creates a new mock instance.
func NewMockSchemaHistory(ctrl *gomock.Controller) *MockSchemaHistory {
	mock := &MockSchemaHistory{ctrl: ctrl}
	mock.recorder = &MockSchemaHistoryMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockSchemaListener is a mock of SchemaListener interface.
type MockSchemaListener struct {
	ctrl     *gomock.Controller
	recorder *MockSchemaListenerMockRecorder
}

// MockSchemaListenerMockRecorder is the mock recorder for MockSchemaListener.
type MockSchemaListenerMockRecorder struct {
	mock *MockSchemaListener
}

// NewMockSchemaListener creates a new mock instance.
func NewMockSchemaListener(ctrl *gomock.Controller) *MockSchemaListener {
	mock := &MockSchemaListener{ctrl: ctrl}
	mock.recorder = &MockSchemaListenerMockRecorder{mock}
	return mock
}

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

// SetSchemaHistory mocks base method.
func (m *MockSchemaListener) SetSchemaHistory(value SchemaHistory) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetSchemaHistory", value)
}

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

// MockSchemaRegistry is a mock of SchemaRegistry interface.
type MockSchemaRegistry struct {
	ctrl     *gomock.Controller
	recorder *MockSchemaRegistryMockRecorder
}

// MockSchemaRegistryMockRecorder is the mock recorder for MockSchemaRegistry.
type MockSchemaRegistryMockRecorder struct {
	mock *MockSchemaRegistry
}

// NewMockSchemaRegistry creates a new mock instance.
func NewMockSchemaRegistry(ctrl *gomock.Controller) *MockSchemaRegistry {
	mock := &MockSchemaRegistry{ctrl: ctrl}
	mock.recorder = &MockSchemaRegistryMockRecorder{mock}
	return mock
}

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

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

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

// GetLatestSchema mocks base method.
func (m *MockSchemaRegistry) GetLatestSchema(id ident.ID) (SchemaDescr, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLatestSchema", id)
	ret0, _ := ret[0].(SchemaDescr)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetSchema mocks base method.
func (m *MockSchemaRegistry) GetSchema(id ident.ID, schemaID string) (SchemaDescr, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSchema", id, schemaID)
	ret0, _ := ret[0].(SchemaDescr)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// RegisterListener mocks base method.
func (m *MockSchemaRegistry) RegisterListener(id ident.ID, listener SchemaListener) (resource.SimpleCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RegisterListener", id, listener)
	ret0, _ := ret[0].(resource.SimpleCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// SetSchemaHistory mocks base method.
func (m *MockSchemaRegistry) SetSchemaHistory(id ident.ID, history SchemaHistory) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSchemaHistory", id, history)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockMetadata is a mock of Metadata interface.
type MockMetadata struct {
	ctrl     *gomock.Controller
	recorder *MockMetadataMockRecorder
}

// MockMetadataMockRecorder is the mock recorder for MockMetadata.
type MockMetadataMockRecorder struct {
	mock *MockMetadata
}

// NewMockMetadata creates a new mock instance.
func NewMockMetadata(ctrl *gomock.Controller) *MockMetadata {
	mock := &MockMetadata{ctrl: ctrl}
	mock.recorder = &MockMetadataMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockMap is a mock of Map interface.
type MockMap struct {
	ctrl     *gomock.Controller
	recorder *MockMapMockRecorder
}

// MockMapMockRecorder is the mock recorder for MockMap.
type MockMapMockRecorder struct {
	mock *MockMap
}

// NewMockMap creates a new mock instance.
func NewMockMap(ctrl *gomock.Controller) *MockMap {
	mock := &MockMap{ctrl: ctrl}
	mock.recorder = &MockMapMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// 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() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// 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() Map {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get")
	ret0, _ := ret[0].(Map)
	return ret0
}

// 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))
}

// MockRegistry is a mock of Registry interface.
type MockRegistry struct {
	ctrl     *gomock.Controller
	recorder *MockRegistryMockRecorder
}

// MockRegistryMockRecorder is the mock recorder for MockRegistry.
type MockRegistryMockRecorder struct {
	mock *MockRegistry
}

// NewMockRegistry creates a new mock instance.
func NewMockRegistry(ctrl *gomock.Controller) *MockRegistry {
	mock := &MockRegistry{ctrl: ctrl}
	mock.recorder = &MockRegistryMockRecorder{mock}
	return mock
}

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

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

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

// Watch mocks base method.
func (m *MockRegistry) 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 *MockRegistryMockRecorder) Watch() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockRegistry)(nil).Watch))
}

// MockInitializer is a mock of Initializer interface.
type MockInitializer struct {
	ctrl     *gomock.Controller
	recorder *MockInitializerMockRecorder
}

// MockInitializerMockRecorder is the mock recorder for MockInitializer.
type MockInitializerMockRecorder struct {
	mock *MockInitializer
}

// NewMockInitializer creates a new mock instance.
func NewMockInitializer(ctrl *gomock.Controller) *MockInitializer {
	mock := &MockInitializer{ctrl: ctrl}
	mock.recorder = &MockInitializerMockRecorder{mock}
	return mock
}

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

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

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

// MockDynamicOptions is a mock of DynamicOptions interface.
type MockDynamicOptions struct {
	ctrl     *gomock.Controller
	recorder *MockDynamicOptionsMockRecorder
}

// MockDynamicOptionsMockRecorder is the mock recorder for MockDynamicOptions.
type MockDynamicOptionsMockRecorder struct {
	mock *MockDynamicOptions
}

// NewMockDynamicOptions creates a new mock instance.
func NewMockDynamicOptions(ctrl *gomock.Controller) *MockDynamicOptions {
	mock := &MockDynamicOptions{ctrl: ctrl}
	mock.recorder = &MockDynamicOptionsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// InstrumentOptions mocks base method.
func (m *MockDynamicOptions) 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 *MockDynamicOptionsMockRecorder) InstrumentOptions() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InstrumentOptions", reflect.TypeOf((*MockDynamicOptions)(nil).InstrumentOptions))
}

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

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

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

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

// SetConfigServiceClient mocks base method.
func (m *MockDynamicOptions) SetConfigServiceClient(c client.Client) DynamicOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetConfigServiceClient", c)
	ret0, _ := ret[0].(DynamicOptions)
	return ret0
}

// SetConfigServiceClient indicates an expected call of SetConfigServiceClient.
func (mr *MockDynamicOptionsMockRecorder) SetConfigServiceClient(c interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetConfigServiceClient", reflect.TypeOf((*MockDynamicOptions)(nil).SetConfigServiceClient), c)
}

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

// SetForceColdWritesEnabled indicates an expected call of SetForceColdWritesEnabled.
func (mr *MockDynamicOptionsMockRecorder) SetForceColdWritesEnabled(enabled interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetForceColdWritesEnabled", reflect.TypeOf((*MockDynamicOptions)(nil).SetForceColdWritesEnabled), enabled)
}

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

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

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

// SetNamespaceRegistryKey indicates an expected call of SetNamespaceRegistryKey.
func (mr *MockDynamicOptionsMockRecorder) SetNamespaceRegistryKey(k interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNamespaceRegistryKey", reflect.TypeOf((*MockDynamicOptions)(nil).SetNamespaceRegistryKey), k)
}

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

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

// MockNamespaceWatch is a mock of NamespaceWatch interface.
type MockNamespaceWatch struct {
	ctrl     *gomock.Controller
	recorder *MockNamespaceWatchMockRecorder
}

// MockNamespaceWatchMockRecorder is the mock recorder for MockNamespaceWatch.
type MockNamespaceWatchMockRecorder struct {
	mock *MockNamespaceWatch
}

// NewMockNamespaceWatch creates a new mock instance.
func NewMockNamespaceWatch(ctrl *gomock.Controller) *MockNamespaceWatch {
	mock := &MockNamespaceWatch{ctrl: ctrl}
	mock.recorder = &MockNamespaceWatchMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockExtendedOptions is a mock of ExtendedOptions interface.
type MockExtendedOptions struct {
	ctrl     *gomock.Controller
	recorder *MockExtendedOptionsMockRecorder
}

// MockExtendedOptionsMockRecorder is the mock recorder for MockExtendedOptions.
type MockExtendedOptionsMockRecorder struct {
	mock *MockExtendedOptions
}

// NewMockExtendedOptions creates a new mock instance.
func NewMockExtendedOptions(ctrl *gomock.Controller) *MockExtendedOptions {
	mock := &MockExtendedOptions{ctrl: ctrl}
	mock.recorder = &MockExtendedOptionsMockRecorder{mock}
	return mock
}

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

// ToProto mocks base method.
func (m *MockExtendedOptions) ToProto() (string, *types.Struct) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ToProto")
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(*types.Struct)
	return ret0, ret1
}

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

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

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

// MockAggregationOptions is a mock of AggregationOptions interface.
type MockAggregationOptions struct {
	ctrl     *gomock.Controller
	recorder *MockAggregationOptionsMockRecorder
}

// MockAggregationOptionsMockRecorder is the mock recorder for MockAggregationOptions.
type MockAggregationOptionsMockRecorder struct {
	mock *MockAggregationOptions
}

// NewMockAggregationOptions creates a new mock instance.
func NewMockAggregationOptions(ctrl *gomock.Controller) *MockAggregationOptions {
	mock := &MockAggregationOptions{ctrl: ctrl}
	mock.recorder = &MockAggregationOptionsMockRecorder{mock}
	return mock
}

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

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

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

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

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

// SetAggregations mocks base method.
func (m *MockAggregationOptions) SetAggregations(value []Aggregation) AggregationOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetAggregations", value)
	ret0, _ := ret[0].(AggregationOptions)
	return ret0
}

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