github.com/m3db/m3@v1.5.1-0.20231129193456-75a402aa583b/src/dbnode/storage/block/block_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: ../../storage/block/types.go

// Copyright (c) 2022 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 block is a generated GoMock package.
package block

import (
	"reflect"
	"time"

	"github.com/m3db/m3/src/dbnode/encoding"
	"github.com/m3db/m3/src/dbnode/namespace"
	"github.com/m3db/m3/src/dbnode/sharding"
	"github.com/m3db/m3/src/dbnode/ts"
	"github.com/m3db/m3/src/dbnode/x/xio"
	"github.com/m3db/m3/src/x/clock"
	"github.com/m3db/m3/src/x/context"
	"github.com/m3db/m3/src/x/ident"
	"github.com/m3db/m3/src/x/pool"
	"github.com/m3db/m3/src/x/sync"
	time0 "github.com/m3db/m3/src/x/time"

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

// MockFilteredBlocksMetadataIter is a mock of FilteredBlocksMetadataIter interface.
type MockFilteredBlocksMetadataIter struct {
	ctrl     *gomock.Controller
	recorder *MockFilteredBlocksMetadataIterMockRecorder
}

// MockFilteredBlocksMetadataIterMockRecorder is the mock recorder for MockFilteredBlocksMetadataIter.
type MockFilteredBlocksMetadataIterMockRecorder struct {
	mock *MockFilteredBlocksMetadataIter
}

// NewMockFilteredBlocksMetadataIter creates a new mock instance.
func NewMockFilteredBlocksMetadataIter(ctrl *gomock.Controller) *MockFilteredBlocksMetadataIter {
	mock := &MockFilteredBlocksMetadataIter{ctrl: ctrl}
	mock.recorder = &MockFilteredBlocksMetadataIterMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// MockFetchBlockMetadataResults is a mock of FetchBlockMetadataResults interface.
type MockFetchBlockMetadataResults struct {
	ctrl     *gomock.Controller
	recorder *MockFetchBlockMetadataResultsMockRecorder
}

// MockFetchBlockMetadataResultsMockRecorder is the mock recorder for MockFetchBlockMetadataResults.
type MockFetchBlockMetadataResultsMockRecorder struct {
	mock *MockFetchBlockMetadataResults
}

// NewMockFetchBlockMetadataResults creates a new mock instance.
func NewMockFetchBlockMetadataResults(ctrl *gomock.Controller) *MockFetchBlockMetadataResults {
	mock := &MockFetchBlockMetadataResults{ctrl: ctrl}
	mock.recorder = &MockFetchBlockMetadataResultsMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockFetchBlockMetadataResults) Add(res FetchBlockMetadataResult) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Add", res)
}

// Add indicates an expected call of Add.
func (mr *MockFetchBlockMetadataResultsMockRecorder) Add(res interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockFetchBlockMetadataResults)(nil).Add), res)
}

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

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

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

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

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

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

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

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

// MockFetchBlocksMetadataResults is a mock of FetchBlocksMetadataResults interface.
type MockFetchBlocksMetadataResults struct {
	ctrl     *gomock.Controller
	recorder *MockFetchBlocksMetadataResultsMockRecorder
}

// MockFetchBlocksMetadataResultsMockRecorder is the mock recorder for MockFetchBlocksMetadataResults.
type MockFetchBlocksMetadataResultsMockRecorder struct {
	mock *MockFetchBlocksMetadataResults
}

// NewMockFetchBlocksMetadataResults creates a new mock instance.
func NewMockFetchBlocksMetadataResults(ctrl *gomock.Controller) *MockFetchBlocksMetadataResults {
	mock := &MockFetchBlocksMetadataResults{ctrl: ctrl}
	mock.recorder = &MockFetchBlocksMetadataResultsMockRecorder{mock}
	return mock
}

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

// Add mocks base method.
func (m *MockFetchBlocksMetadataResults) Add(res FetchBlocksMetadataResult) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Add", res)
}

// Add indicates an expected call of Add.
func (mr *MockFetchBlocksMetadataResultsMockRecorder) Add(res interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockFetchBlocksMetadataResults)(nil).Add), res)
}

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

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

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

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

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

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

// MockDatabaseBlock is a mock of DatabaseBlock interface.
type MockDatabaseBlock struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseBlockMockRecorder
}

// MockDatabaseBlockMockRecorder is the mock recorder for MockDatabaseBlock.
type MockDatabaseBlockMockRecorder struct {
	mock *MockDatabaseBlock
}

// NewMockDatabaseBlock creates a new mock instance.
func NewMockDatabaseBlock(ctrl *gomock.Controller) *MockDatabaseBlock {
	mock := &MockDatabaseBlock{ctrl: ctrl}
	mock.recorder = &MockDatabaseBlockMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Merge indicates an expected call of Merge.
func (mr *MockDatabaseBlockMockRecorder) Merge(other interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Merge", reflect.TypeOf((*MockDatabaseBlock)(nil).Merge), other)
}

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

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

// Reset mocks base method.
func (m *MockDatabaseBlock) Reset(startTime time0.UnixNano, blockSize time.Duration, segment ts.Segment, nsCtx namespace.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", startTime, blockSize, segment, nsCtx)
}

// Reset indicates an expected call of Reset.
func (mr *MockDatabaseBlockMockRecorder) Reset(startTime, blockSize, segment, nsCtx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockDatabaseBlock)(nil).Reset), startTime, blockSize, segment, nsCtx)
}

// ResetFromDisk mocks base method.
func (m *MockDatabaseBlock) ResetFromDisk(startTime time0.UnixNano, blockSize time.Duration, segment ts.Segment, id ident.ID, nsCtx namespace.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ResetFromDisk", startTime, blockSize, segment, id, nsCtx)
}

// ResetFromDisk indicates an expected call of ResetFromDisk.
func (mr *MockDatabaseBlockMockRecorder) ResetFromDisk(startTime, blockSize, segment, id, nsCtx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResetFromDisk", reflect.TypeOf((*MockDatabaseBlock)(nil).ResetFromDisk), startTime, blockSize, segment, id, nsCtx)
}

// SetLastReadTime mocks base method.
func (m *MockDatabaseBlock) SetLastReadTime(value time0.UnixNano) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetLastReadTime", value)
}

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

// SetOnEvictedFromWiredList mocks base method.
func (m *MockDatabaseBlock) SetOnEvictedFromWiredList(arg0 OnEvictedFromWiredList) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetOnEvictedFromWiredList", arg0)
}

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

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

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

// Stream mocks base method.
func (m *MockDatabaseBlock) Stream(blocker context.Context) (xio.BlockReader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stream", blocker)
	ret0, _ := ret[0].(xio.BlockReader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stream indicates an expected call of Stream.
func (mr *MockDatabaseBlockMockRecorder) Stream(blocker interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockDatabaseBlock)(nil).Stream), blocker)
}

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

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

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

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

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

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

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

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

// setEnteredListAtUnixNano mocks base method.
func (m *MockDatabaseBlock) setEnteredListAtUnixNano(value int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "setEnteredListAtUnixNano", value)
}

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

// setNext mocks base method.
func (m *MockDatabaseBlock) setNext(block DatabaseBlock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "setNext", block)
}

// setNext indicates an expected call of setNext.
func (mr *MockDatabaseBlockMockRecorder) setNext(block interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setNext", reflect.TypeOf((*MockDatabaseBlock)(nil).setNext), block)
}

// setPrev mocks base method.
func (m *MockDatabaseBlock) setPrev(block DatabaseBlock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "setPrev", block)
}

// setPrev indicates an expected call of setPrev.
func (mr *MockDatabaseBlockMockRecorder) setPrev(block interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setPrev", reflect.TypeOf((*MockDatabaseBlock)(nil).setPrev), block)
}

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

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

// MockdatabaseBlock is a mock of databaseBlock interface.
type MockdatabaseBlock struct {
	ctrl     *gomock.Controller
	recorder *MockdatabaseBlockMockRecorder
}

// MockdatabaseBlockMockRecorder is the mock recorder for MockdatabaseBlock.
type MockdatabaseBlockMockRecorder struct {
	mock *MockdatabaseBlock
}

// NewMockdatabaseBlock creates a new mock instance.
func NewMockdatabaseBlock(ctrl *gomock.Controller) *MockdatabaseBlock {
	mock := &MockdatabaseBlock{ctrl: ctrl}
	mock.recorder = &MockdatabaseBlockMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

// setEnteredListAtUnixNano mocks base method.
func (m *MockdatabaseBlock) setEnteredListAtUnixNano(value int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "setEnteredListAtUnixNano", value)
}

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

// setNext mocks base method.
func (m *MockdatabaseBlock) setNext(block DatabaseBlock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "setNext", block)
}

// setNext indicates an expected call of setNext.
func (mr *MockdatabaseBlockMockRecorder) setNext(block interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setNext", reflect.TypeOf((*MockdatabaseBlock)(nil).setNext), block)
}

// setPrev mocks base method.
func (m *MockdatabaseBlock) setPrev(block DatabaseBlock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "setPrev", block)
}

// setPrev indicates an expected call of setPrev.
func (mr *MockdatabaseBlockMockRecorder) setPrev(block interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "setPrev", reflect.TypeOf((*MockdatabaseBlock)(nil).setPrev), block)
}

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

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

// MockOnEvictedFromWiredList is a mock of OnEvictedFromWiredList interface.
type MockOnEvictedFromWiredList struct {
	ctrl     *gomock.Controller
	recorder *MockOnEvictedFromWiredListMockRecorder
}

// MockOnEvictedFromWiredListMockRecorder is the mock recorder for MockOnEvictedFromWiredList.
type MockOnEvictedFromWiredListMockRecorder struct {
	mock *MockOnEvictedFromWiredList
}

// NewMockOnEvictedFromWiredList creates a new mock instance.
func NewMockOnEvictedFromWiredList(ctrl *gomock.Controller) *MockOnEvictedFromWiredList {
	mock := &MockOnEvictedFromWiredList{ctrl: ctrl}
	mock.recorder = &MockOnEvictedFromWiredListMockRecorder{mock}
	return mock
}

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

// OnEvictedFromWiredList mocks base method.
func (m *MockOnEvictedFromWiredList) OnEvictedFromWiredList(id ident.ID, blockStart time0.UnixNano) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnEvictedFromWiredList", id, blockStart)
}

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

// MockOnRetrieveBlock is a mock of OnRetrieveBlock interface.
type MockOnRetrieveBlock struct {
	ctrl     *gomock.Controller
	recorder *MockOnRetrieveBlockMockRecorder
}

// MockOnRetrieveBlockMockRecorder is the mock recorder for MockOnRetrieveBlock.
type MockOnRetrieveBlockMockRecorder struct {
	mock *MockOnRetrieveBlock
}

// NewMockOnRetrieveBlock creates a new mock instance.
func NewMockOnRetrieveBlock(ctrl *gomock.Controller) *MockOnRetrieveBlock {
	mock := &MockOnRetrieveBlock{ctrl: ctrl}
	mock.recorder = &MockOnRetrieveBlockMockRecorder{mock}
	return mock
}

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

// OnRetrieveBlock mocks base method.
func (m *MockOnRetrieveBlock) OnRetrieveBlock(id ident.ID, tags ident.TagIterator, startTime time0.UnixNano, segment ts.Segment, nsCtx namespace.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnRetrieveBlock", id, tags, startTime, segment, nsCtx)
}

// OnRetrieveBlock indicates an expected call of OnRetrieveBlock.
func (mr *MockOnRetrieveBlockMockRecorder) OnRetrieveBlock(id, tags, startTime, segment, nsCtx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnRetrieveBlock", reflect.TypeOf((*MockOnRetrieveBlock)(nil).OnRetrieveBlock), id, tags, startTime, segment, nsCtx)
}

// MockOnReadBlock is a mock of OnReadBlock interface.
type MockOnReadBlock struct {
	ctrl     *gomock.Controller
	recorder *MockOnReadBlockMockRecorder
}

// MockOnReadBlockMockRecorder is the mock recorder for MockOnReadBlock.
type MockOnReadBlockMockRecorder struct {
	mock *MockOnReadBlock
}

// NewMockOnReadBlock creates a new mock instance.
func NewMockOnReadBlock(ctrl *gomock.Controller) *MockOnReadBlock {
	mock := &MockOnReadBlock{ctrl: ctrl}
	mock.recorder = &MockOnReadBlockMockRecorder{mock}
	return mock
}

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

// OnReadBlock mocks base method.
func (m *MockOnReadBlock) OnReadBlock(b DatabaseBlock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "OnReadBlock", b)
}

// OnReadBlock indicates an expected call of OnReadBlock.
func (mr *MockOnReadBlockMockRecorder) OnReadBlock(b interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnReadBlock", reflect.TypeOf((*MockOnReadBlock)(nil).OnReadBlock), b)
}

// MockDatabaseBlockRetriever is a mock of DatabaseBlockRetriever interface.
type MockDatabaseBlockRetriever struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseBlockRetrieverMockRecorder
}

// MockDatabaseBlockRetrieverMockRecorder is the mock recorder for MockDatabaseBlockRetriever.
type MockDatabaseBlockRetrieverMockRecorder struct {
	mock *MockDatabaseBlockRetriever
}

// NewMockDatabaseBlockRetriever creates a new mock instance.
func NewMockDatabaseBlockRetriever(ctrl *gomock.Controller) *MockDatabaseBlockRetriever {
	mock := &MockDatabaseBlockRetriever{ctrl: ctrl}
	mock.recorder = &MockDatabaseBlockRetrieverMockRecorder{mock}
	return mock
}

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

// AssignShardSet mocks base method.
func (m *MockDatabaseBlockRetriever) AssignShardSet(shardSet sharding.ShardSet) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AssignShardSet", shardSet)
}

// AssignShardSet indicates an expected call of AssignShardSet.
func (mr *MockDatabaseBlockRetrieverMockRecorder) AssignShardSet(shardSet interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignShardSet", reflect.TypeOf((*MockDatabaseBlockRetriever)(nil).AssignShardSet), shardSet)
}

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

// CacheShardIndices indicates an expected call of CacheShardIndices.
func (mr *MockDatabaseBlockRetrieverMockRecorder) CacheShardIndices(shards interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CacheShardIndices", reflect.TypeOf((*MockDatabaseBlockRetriever)(nil).CacheShardIndices), shards)
}

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

// Stream mocks base method.
func (m *MockDatabaseBlockRetriever) Stream(ctx context.Context, shard uint32, id ident.ID, blockStart time0.UnixNano, onRetrieve OnRetrieveBlock, nsCtx namespace.Context) (xio.BlockReader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stream", ctx, shard, id, blockStart, onRetrieve, nsCtx)
	ret0, _ := ret[0].(xio.BlockReader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stream indicates an expected call of Stream.
func (mr *MockDatabaseBlockRetrieverMockRecorder) Stream(ctx, shard, id, blockStart, onRetrieve, nsCtx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockDatabaseBlockRetriever)(nil).Stream), ctx, shard, id, blockStart, onRetrieve, nsCtx)
}

// MockDatabaseShardBlockRetriever is a mock of DatabaseShardBlockRetriever interface.
type MockDatabaseShardBlockRetriever struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseShardBlockRetrieverMockRecorder
}

// MockDatabaseShardBlockRetrieverMockRecorder is the mock recorder for MockDatabaseShardBlockRetriever.
type MockDatabaseShardBlockRetrieverMockRecorder struct {
	mock *MockDatabaseShardBlockRetriever
}

// NewMockDatabaseShardBlockRetriever creates a new mock instance.
func NewMockDatabaseShardBlockRetriever(ctrl *gomock.Controller) *MockDatabaseShardBlockRetriever {
	mock := &MockDatabaseShardBlockRetriever{ctrl: ctrl}
	mock.recorder = &MockDatabaseShardBlockRetrieverMockRecorder{mock}
	return mock
}

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

// Stream mocks base method.
func (m *MockDatabaseShardBlockRetriever) Stream(ctx context.Context, id ident.ID, blockStart time0.UnixNano, onRetrieve OnRetrieveBlock, nsCtx namespace.Context) (xio.BlockReader, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Stream", ctx, id, blockStart, onRetrieve, nsCtx)
	ret0, _ := ret[0].(xio.BlockReader)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Stream indicates an expected call of Stream.
func (mr *MockDatabaseShardBlockRetrieverMockRecorder) Stream(ctx, id, blockStart, onRetrieve, nsCtx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockDatabaseShardBlockRetriever)(nil).Stream), ctx, id, blockStart, onRetrieve, nsCtx)
}

// MockDatabaseBlockRetrieverManager is a mock of DatabaseBlockRetrieverManager interface.
type MockDatabaseBlockRetrieverManager struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseBlockRetrieverManagerMockRecorder
}

// MockDatabaseBlockRetrieverManagerMockRecorder is the mock recorder for MockDatabaseBlockRetrieverManager.
type MockDatabaseBlockRetrieverManagerMockRecorder struct {
	mock *MockDatabaseBlockRetrieverManager
}

// NewMockDatabaseBlockRetrieverManager creates a new mock instance.
func NewMockDatabaseBlockRetrieverManager(ctrl *gomock.Controller) *MockDatabaseBlockRetrieverManager {
	mock := &MockDatabaseBlockRetrieverManager{ctrl: ctrl}
	mock.recorder = &MockDatabaseBlockRetrieverManagerMockRecorder{mock}
	return mock
}

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

// Retriever mocks base method.
func (m *MockDatabaseBlockRetrieverManager) Retriever(nsMetadata namespace.Metadata, shardSet sharding.ShardSet) (DatabaseBlockRetriever, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Retriever", nsMetadata, shardSet)
	ret0, _ := ret[0].(DatabaseBlockRetriever)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Retriever indicates an expected call of Retriever.
func (mr *MockDatabaseBlockRetrieverManagerMockRecorder) Retriever(nsMetadata, shardSet interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retriever", reflect.TypeOf((*MockDatabaseBlockRetrieverManager)(nil).Retriever), nsMetadata, shardSet)
}

// MockDatabaseShardBlockRetrieverManager is a mock of DatabaseShardBlockRetrieverManager interface.
type MockDatabaseShardBlockRetrieverManager struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseShardBlockRetrieverManagerMockRecorder
}

// MockDatabaseShardBlockRetrieverManagerMockRecorder is the mock recorder for MockDatabaseShardBlockRetrieverManager.
type MockDatabaseShardBlockRetrieverManagerMockRecorder struct {
	mock *MockDatabaseShardBlockRetrieverManager
}

// NewMockDatabaseShardBlockRetrieverManager creates a new mock instance.
func NewMockDatabaseShardBlockRetrieverManager(ctrl *gomock.Controller) *MockDatabaseShardBlockRetrieverManager {
	mock := &MockDatabaseShardBlockRetrieverManager{ctrl: ctrl}
	mock.recorder = &MockDatabaseShardBlockRetrieverManagerMockRecorder{mock}
	return mock
}

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

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

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

// MockDatabaseSeriesBlocks is a mock of DatabaseSeriesBlocks interface.
type MockDatabaseSeriesBlocks struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseSeriesBlocksMockRecorder
}

// MockDatabaseSeriesBlocksMockRecorder is the mock recorder for MockDatabaseSeriesBlocks.
type MockDatabaseSeriesBlocksMockRecorder struct {
	mock *MockDatabaseSeriesBlocks
}

// NewMockDatabaseSeriesBlocks creates a new mock instance.
func NewMockDatabaseSeriesBlocks(ctrl *gomock.Controller) *MockDatabaseSeriesBlocks {
	mock := &MockDatabaseSeriesBlocks{ctrl: ctrl}
	mock.recorder = &MockDatabaseSeriesBlocksMockRecorder{mock}
	return mock
}

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

// AddBlock mocks base method.
func (m *MockDatabaseSeriesBlocks) AddBlock(block DatabaseBlock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddBlock", block)
}

// AddBlock indicates an expected call of AddBlock.
func (mr *MockDatabaseSeriesBlocksMockRecorder) AddBlock(block interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddBlock", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).AddBlock), block)
}

// AddSeries mocks base method.
func (m *MockDatabaseSeriesBlocks) AddSeries(other DatabaseSeriesBlocks) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddSeries", other)
}

// AddSeries indicates an expected call of AddSeries.
func (mr *MockDatabaseSeriesBlocksMockRecorder) AddSeries(other interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSeries", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).AddSeries), other)
}

// AllBlocks mocks base method.
func (m *MockDatabaseSeriesBlocks) AllBlocks() map[time0.UnixNano]DatabaseBlock {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AllBlocks")
	ret0, _ := ret[0].(map[time0.UnixNano]DatabaseBlock)
	return ret0
}

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

// BlockAt mocks base method.
func (m *MockDatabaseSeriesBlocks) BlockAt(t time0.UnixNano) (DatabaseBlock, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BlockAt", t)
	ret0, _ := ret[0].(DatabaseBlock)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// BlockAt indicates an expected call of BlockAt.
func (mr *MockDatabaseSeriesBlocksMockRecorder) BlockAt(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BlockAt", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).BlockAt), t)
}

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

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

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

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

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

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

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

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

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

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

// RemoveBlockAt mocks base method.
func (m *MockDatabaseSeriesBlocks) RemoveBlockAt(t time0.UnixNano) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RemoveBlockAt", t)
}

// RemoveBlockAt indicates an expected call of RemoveBlockAt.
func (mr *MockDatabaseSeriesBlocksMockRecorder) RemoveBlockAt(t interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveBlockAt", reflect.TypeOf((*MockDatabaseSeriesBlocks)(nil).RemoveBlockAt), t)
}

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

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

// MockDatabaseBlockPool is a mock of DatabaseBlockPool interface.
type MockDatabaseBlockPool struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseBlockPoolMockRecorder
}

// MockDatabaseBlockPoolMockRecorder is the mock recorder for MockDatabaseBlockPool.
type MockDatabaseBlockPoolMockRecorder struct {
	mock *MockDatabaseBlockPool
}

// NewMockDatabaseBlockPool creates a new mock instance.
func NewMockDatabaseBlockPool(ctrl *gomock.Controller) *MockDatabaseBlockPool {
	mock := &MockDatabaseBlockPool{ctrl: ctrl}
	mock.recorder = &MockDatabaseBlockPoolMockRecorder{mock}
	return mock
}

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

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

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

// Init mocks base method.
func (m *MockDatabaseBlockPool) Init(alloc DatabaseBlockAllocate) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Init", alloc)
}

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

// Put mocks base method.
func (m *MockDatabaseBlockPool) Put(block DatabaseBlock) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", block)
}

// Put indicates an expected call of Put.
func (mr *MockDatabaseBlockPoolMockRecorder) Put(block interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockDatabaseBlockPool)(nil).Put), block)
}

// MockFetchBlockMetadataResultsPool is a mock of FetchBlockMetadataResultsPool interface.
type MockFetchBlockMetadataResultsPool struct {
	ctrl     *gomock.Controller
	recorder *MockFetchBlockMetadataResultsPoolMockRecorder
}

// MockFetchBlockMetadataResultsPoolMockRecorder is the mock recorder for MockFetchBlockMetadataResultsPool.
type MockFetchBlockMetadataResultsPoolMockRecorder struct {
	mock *MockFetchBlockMetadataResultsPool
}

// NewMockFetchBlockMetadataResultsPool creates a new mock instance.
func NewMockFetchBlockMetadataResultsPool(ctrl *gomock.Controller) *MockFetchBlockMetadataResultsPool {
	mock := &MockFetchBlockMetadataResultsPool{ctrl: ctrl}
	mock.recorder = &MockFetchBlockMetadataResultsPoolMockRecorder{mock}
	return mock
}

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

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

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

// Put mocks base method.
func (m *MockFetchBlockMetadataResultsPool) Put(res FetchBlockMetadataResults) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", res)
}

// Put indicates an expected call of Put.
func (mr *MockFetchBlockMetadataResultsPoolMockRecorder) Put(res interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockFetchBlockMetadataResultsPool)(nil).Put), res)
}

// MockFetchBlocksMetadataResultsPool is a mock of FetchBlocksMetadataResultsPool interface.
type MockFetchBlocksMetadataResultsPool struct {
	ctrl     *gomock.Controller
	recorder *MockFetchBlocksMetadataResultsPoolMockRecorder
}

// MockFetchBlocksMetadataResultsPoolMockRecorder is the mock recorder for MockFetchBlocksMetadataResultsPool.
type MockFetchBlocksMetadataResultsPoolMockRecorder struct {
	mock *MockFetchBlocksMetadataResultsPool
}

// NewMockFetchBlocksMetadataResultsPool creates a new mock instance.
func NewMockFetchBlocksMetadataResultsPool(ctrl *gomock.Controller) *MockFetchBlocksMetadataResultsPool {
	mock := &MockFetchBlocksMetadataResultsPool{ctrl: ctrl}
	mock.recorder = &MockFetchBlocksMetadataResultsPoolMockRecorder{mock}
	return mock
}

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

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

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

// Put mocks base method.
func (m *MockFetchBlocksMetadataResultsPool) Put(res FetchBlocksMetadataResults) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", res)
}

// Put indicates an expected call of Put.
func (mr *MockFetchBlocksMetadataResultsPoolMockRecorder) Put(res interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockFetchBlocksMetadataResultsPool)(nil).Put), res)
}

// MockLeaseManager is a mock of LeaseManager interface.
type MockLeaseManager struct {
	ctrl     *gomock.Controller
	recorder *MockLeaseManagerMockRecorder
}

// MockLeaseManagerMockRecorder is the mock recorder for MockLeaseManager.
type MockLeaseManagerMockRecorder struct {
	mock *MockLeaseManager
}

// NewMockLeaseManager creates a new mock instance.
func NewMockLeaseManager(ctrl *gomock.Controller) *MockLeaseManager {
	mock := &MockLeaseManager{ctrl: ctrl}
	mock.recorder = &MockLeaseManagerMockRecorder{mock}
	return mock
}

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

// OpenLatestLease mocks base method.
func (m *MockLeaseManager) OpenLatestLease(leaser Leaser, descriptor LeaseDescriptor) (LeaseState, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenLatestLease", leaser, descriptor)
	ret0, _ := ret[0].(LeaseState)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// OpenLatestLease indicates an expected call of OpenLatestLease.
func (mr *MockLeaseManagerMockRecorder) OpenLatestLease(leaser, descriptor interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenLatestLease", reflect.TypeOf((*MockLeaseManager)(nil).OpenLatestLease), leaser, descriptor)
}

// OpenLease mocks base method.
func (m *MockLeaseManager) OpenLease(leaser Leaser, descriptor LeaseDescriptor, state LeaseState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "OpenLease", leaser, descriptor, state)
	ret0, _ := ret[0].(error)
	return ret0
}

// OpenLease indicates an expected call of OpenLease.
func (mr *MockLeaseManagerMockRecorder) OpenLease(leaser, descriptor, state interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OpenLease", reflect.TypeOf((*MockLeaseManager)(nil).OpenLease), leaser, descriptor, state)
}

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

// RegisterLeaser indicates an expected call of RegisterLeaser.
func (mr *MockLeaseManagerMockRecorder) RegisterLeaser(leaser interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterLeaser", reflect.TypeOf((*MockLeaseManager)(nil).RegisterLeaser), leaser)
}

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

// SetLeaseVerifier indicates an expected call of SetLeaseVerifier.
func (mr *MockLeaseManagerMockRecorder) SetLeaseVerifier(leaseVerifier interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetLeaseVerifier", reflect.TypeOf((*MockLeaseManager)(nil).SetLeaseVerifier), leaseVerifier)
}

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

// UnregisterLeaser indicates an expected call of UnregisterLeaser.
func (mr *MockLeaseManagerMockRecorder) UnregisterLeaser(leaser interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnregisterLeaser", reflect.TypeOf((*MockLeaseManager)(nil).UnregisterLeaser), leaser)
}

// UpdateOpenLeases mocks base method.
func (m *MockLeaseManager) UpdateOpenLeases(descriptor LeaseDescriptor, state LeaseState) (UpdateLeasesResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOpenLeases", descriptor, state)
	ret0, _ := ret[0].(UpdateLeasesResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOpenLeases indicates an expected call of UpdateOpenLeases.
func (mr *MockLeaseManagerMockRecorder) UpdateOpenLeases(descriptor, state interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpenLeases", reflect.TypeOf((*MockLeaseManager)(nil).UpdateOpenLeases), descriptor, state)
}

// MockLeaseVerifier is a mock of LeaseVerifier interface.
type MockLeaseVerifier struct {
	ctrl     *gomock.Controller
	recorder *MockLeaseVerifierMockRecorder
}

// MockLeaseVerifierMockRecorder is the mock recorder for MockLeaseVerifier.
type MockLeaseVerifierMockRecorder struct {
	mock *MockLeaseVerifier
}

// NewMockLeaseVerifier creates a new mock instance.
func NewMockLeaseVerifier(ctrl *gomock.Controller) *MockLeaseVerifier {
	mock := &MockLeaseVerifier{ctrl: ctrl}
	mock.recorder = &MockLeaseVerifierMockRecorder{mock}
	return mock
}

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

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

// LatestState indicates an expected call of LatestState.
func (mr *MockLeaseVerifierMockRecorder) LatestState(descriptor interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LatestState", reflect.TypeOf((*MockLeaseVerifier)(nil).LatestState), descriptor)
}

// VerifyLease mocks base method.
func (m *MockLeaseVerifier) VerifyLease(descriptor LeaseDescriptor, state LeaseState) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VerifyLease", descriptor, state)
	ret0, _ := ret[0].(error)
	return ret0
}

// VerifyLease indicates an expected call of VerifyLease.
func (mr *MockLeaseVerifierMockRecorder) VerifyLease(descriptor, state interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyLease", reflect.TypeOf((*MockLeaseVerifier)(nil).VerifyLease), descriptor, state)
}

// MockLeaser is a mock of Leaser interface.
type MockLeaser struct {
	ctrl     *gomock.Controller
	recorder *MockLeaserMockRecorder
}

// MockLeaserMockRecorder is the mock recorder for MockLeaser.
type MockLeaserMockRecorder struct {
	mock *MockLeaser
}

// NewMockLeaser creates a new mock instance.
func NewMockLeaser(ctrl *gomock.Controller) *MockLeaser {
	mock := &MockLeaser{ctrl: ctrl}
	mock.recorder = &MockLeaserMockRecorder{mock}
	return mock
}

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

// UpdateOpenLease mocks base method.
func (m *MockLeaser) UpdateOpenLease(descriptor LeaseDescriptor, state LeaseState) (UpdateOpenLeaseResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateOpenLease", descriptor, state)
	ret0, _ := ret[0].(UpdateOpenLeaseResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOpenLease indicates an expected call of UpdateOpenLease.
func (mr *MockLeaserMockRecorder) UpdateOpenLease(descriptor, state interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOpenLease", reflect.TypeOf((*MockLeaser)(nil).UpdateOpenLease), descriptor, state)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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