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

// Code generated by MockGen. DO NOT EDIT.
// Source: ../../storage/index/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 index is a generated GoMock package.
package index

import (
	"reflect"
	"time"

	"github.com/m3db/m3/src/dbnode/storage/bootstrap/result"
	"github.com/m3db/m3/src/dbnode/storage/index/compaction"
	"github.com/m3db/m3/src/dbnode/storage/limits"
	"github.com/m3db/m3/src/m3ninx/doc"
	"github.com/m3db/m3/src/m3ninx/index/segment/builder"
	"github.com/m3db/m3/src/m3ninx/index/segment/fst"
	"github.com/m3db/m3/src/m3ninx/index/segment/mem"
	"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/instrument"
	"github.com/m3db/m3/src/x/mmap"
	"github.com/m3db/m3/src/x/pool"
	time0 "github.com/m3db/m3/src/x/time"

	"github.com/golang/mock/gomock"
	"github.com/opentracing/opentracing-go/log"
)

// MockBaseResults is a mock of BaseResults interface.
type MockBaseResults struct {
	ctrl     *gomock.Controller
	recorder *MockBaseResultsMockRecorder
}

// MockBaseResultsMockRecorder is the mock recorder for MockBaseResults.
type MockBaseResultsMockRecorder struct {
	mock *MockBaseResults
}

// NewMockBaseResults creates a new mock instance.
func NewMockBaseResults(ctrl *gomock.Controller) *MockBaseResults {
	mock := &MockBaseResults{ctrl: ctrl}
	mock.recorder = &MockBaseResultsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockDocumentResults is a mock of DocumentResults interface.
type MockDocumentResults struct {
	ctrl     *gomock.Controller
	recorder *MockDocumentResultsMockRecorder
}

// MockDocumentResultsMockRecorder is the mock recorder for MockDocumentResults.
type MockDocumentResultsMockRecorder struct {
	mock *MockDocumentResults
}

// NewMockDocumentResults creates a new mock instance.
func NewMockDocumentResults(ctrl *gomock.Controller) *MockDocumentResults {
	mock := &MockDocumentResults{ctrl: ctrl}
	mock.recorder = &MockDocumentResultsMockRecorder{mock}
	return mock
}

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

// AddDocuments mocks base method.
func (m *MockDocumentResults) AddDocuments(batch []doc.Document) (int, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddDocuments", batch)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddDocuments indicates an expected call of AddDocuments.
func (mr *MockDocumentResultsMockRecorder) AddDocuments(batch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDocuments", reflect.TypeOf((*MockDocumentResults)(nil).AddDocuments), batch)
}

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

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

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

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

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

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

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

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

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

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

// MockQueryResults is a mock of QueryResults interface.
type MockQueryResults struct {
	ctrl     *gomock.Controller
	recorder *MockQueryResultsMockRecorder
}

// MockQueryResultsMockRecorder is the mock recorder for MockQueryResults.
type MockQueryResultsMockRecorder struct {
	mock *MockQueryResults
}

// NewMockQueryResults creates a new mock instance.
func NewMockQueryResults(ctrl *gomock.Controller) *MockQueryResults {
	mock := &MockQueryResults{ctrl: ctrl}
	mock.recorder = &MockQueryResultsMockRecorder{mock}
	return mock
}

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

// AddDocuments mocks base method.
func (m *MockQueryResults) AddDocuments(batch []doc.Document) (int, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddDocuments", batch)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// AddDocuments indicates an expected call of AddDocuments.
func (mr *MockQueryResultsMockRecorder) AddDocuments(batch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDocuments", reflect.TypeOf((*MockQueryResults)(nil).AddDocuments), batch)
}

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

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

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

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

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

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

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

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

// Reset mocks base method.
func (m *MockQueryResults) Reset(nsID ident.ID, opts QueryResultsOptions) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", nsID, opts)
}

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

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

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

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

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

// MockQueryResultsPool is a mock of QueryResultsPool interface.
type MockQueryResultsPool struct {
	ctrl     *gomock.Controller
	recorder *MockQueryResultsPoolMockRecorder
}

// MockQueryResultsPoolMockRecorder is the mock recorder for MockQueryResultsPool.
type MockQueryResultsPoolMockRecorder struct {
	mock *MockQueryResultsPool
}

// NewMockQueryResultsPool creates a new mock instance.
func NewMockQueryResultsPool(ctrl *gomock.Controller) *MockQueryResultsPool {
	mock := &MockQueryResultsPool{ctrl: ctrl}
	mock.recorder = &MockQueryResultsPoolMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Put mocks base method.
func (m *MockQueryResultsPool) Put(value QueryResults) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", value)
}

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

// MockAggregateResults is a mock of AggregateResults interface.
type MockAggregateResults struct {
	ctrl     *gomock.Controller
	recorder *MockAggregateResultsMockRecorder
}

// MockAggregateResultsMockRecorder is the mock recorder for MockAggregateResults.
type MockAggregateResultsMockRecorder struct {
	mock *MockAggregateResults
}

// NewMockAggregateResults creates a new mock instance.
func NewMockAggregateResults(ctrl *gomock.Controller) *MockAggregateResults {
	mock := &MockAggregateResults{ctrl: ctrl}
	mock.recorder = &MockAggregateResultsMockRecorder{mock}
	return mock
}

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

// AddFields mocks base method.
func (m *MockAggregateResults) AddFields(batch []AggregateResultsEntry) (int, int) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddFields", batch)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(int)
	return ret0, ret1
}

// AddFields indicates an expected call of AddFields.
func (mr *MockAggregateResultsMockRecorder) AddFields(batch interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddFields", reflect.TypeOf((*MockAggregateResults)(nil).AddFields), batch)
}

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

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

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

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

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

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

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

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

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

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

// Reset mocks base method.
func (m *MockAggregateResults) Reset(nsID ident.ID, aggregateQueryOpts AggregateResultsOptions) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", nsID, aggregateQueryOpts)
}

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

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

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

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

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

// MockAggregateUsageMetrics is a mock of AggregateUsageMetrics interface.
type MockAggregateUsageMetrics struct {
	ctrl     *gomock.Controller
	recorder *MockAggregateUsageMetricsMockRecorder
}

// MockAggregateUsageMetricsMockRecorder is the mock recorder for MockAggregateUsageMetrics.
type MockAggregateUsageMetricsMockRecorder struct {
	mock *MockAggregateUsageMetrics
}

// NewMockAggregateUsageMetrics creates a new mock instance.
func NewMockAggregateUsageMetrics(ctrl *gomock.Controller) *MockAggregateUsageMetrics {
	mock := &MockAggregateUsageMetrics{ctrl: ctrl}
	mock.recorder = &MockAggregateUsageMetricsMockRecorder{mock}
	return mock
}

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

// IncDedupedFields mocks base method.
func (m *MockAggregateUsageMetrics) IncDedupedFields(val int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncDedupedFields", val)
}

// IncDedupedFields indicates an expected call of IncDedupedFields.
func (mr *MockAggregateUsageMetricsMockRecorder) IncDedupedFields(val interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncDedupedFields", reflect.TypeOf((*MockAggregateUsageMetrics)(nil).IncDedupedFields), val)
}

// IncDedupedTerms mocks base method.
func (m *MockAggregateUsageMetrics) IncDedupedTerms(val int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncDedupedTerms", val)
}

// IncDedupedTerms indicates an expected call of IncDedupedTerms.
func (mr *MockAggregateUsageMetricsMockRecorder) IncDedupedTerms(val interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncDedupedTerms", reflect.TypeOf((*MockAggregateUsageMetrics)(nil).IncDedupedTerms), val)
}

// IncTotal mocks base method.
func (m *MockAggregateUsageMetrics) IncTotal(val int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotal", val)
}

// IncTotal indicates an expected call of IncTotal.
func (mr *MockAggregateUsageMetricsMockRecorder) IncTotal(val interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotal", reflect.TypeOf((*MockAggregateUsageMetrics)(nil).IncTotal), val)
}

// IncTotalFields mocks base method.
func (m *MockAggregateUsageMetrics) IncTotalFields(val int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotalFields", val)
}

// IncTotalFields indicates an expected call of IncTotalFields.
func (mr *MockAggregateUsageMetricsMockRecorder) IncTotalFields(val interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotalFields", reflect.TypeOf((*MockAggregateUsageMetrics)(nil).IncTotalFields), val)
}

// IncTotalTerms mocks base method.
func (m *MockAggregateUsageMetrics) IncTotalTerms(val int64) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "IncTotalTerms", val)
}

// IncTotalTerms indicates an expected call of IncTotalTerms.
func (mr *MockAggregateUsageMetricsMockRecorder) IncTotalTerms(val interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncTotalTerms", reflect.TypeOf((*MockAggregateUsageMetrics)(nil).IncTotalTerms), val)
}

// MockAggregateResultsPool is a mock of AggregateResultsPool interface.
type MockAggregateResultsPool struct {
	ctrl     *gomock.Controller
	recorder *MockAggregateResultsPoolMockRecorder
}

// MockAggregateResultsPoolMockRecorder is the mock recorder for MockAggregateResultsPool.
type MockAggregateResultsPoolMockRecorder struct {
	mock *MockAggregateResultsPool
}

// NewMockAggregateResultsPool creates a new mock instance.
func NewMockAggregateResultsPool(ctrl *gomock.Controller) *MockAggregateResultsPool {
	mock := &MockAggregateResultsPool{ctrl: ctrl}
	mock.recorder = &MockAggregateResultsPoolMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Put mocks base method.
func (m *MockAggregateResultsPool) Put(value AggregateResults) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", value)
}

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

// MockAggregateValuesPool is a mock of AggregateValuesPool interface.
type MockAggregateValuesPool struct {
	ctrl     *gomock.Controller
	recorder *MockAggregateValuesPoolMockRecorder
}

// MockAggregateValuesPoolMockRecorder is the mock recorder for MockAggregateValuesPool.
type MockAggregateValuesPoolMockRecorder struct {
	mock *MockAggregateValuesPool
}

// NewMockAggregateValuesPool creates a new mock instance.
func NewMockAggregateValuesPool(ctrl *gomock.Controller) *MockAggregateValuesPool {
	mock := &MockAggregateValuesPool{ctrl: ctrl}
	mock.recorder = &MockAggregateValuesPoolMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Put mocks base method.
func (m *MockAggregateValuesPool) Put(value AggregateValues) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Put", value)
}

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

// MockBlock is a mock of Block interface.
type MockBlock struct {
	ctrl     *gomock.Controller
	recorder *MockBlockMockRecorder
}

// MockBlockMockRecorder is the mock recorder for MockBlock.
type MockBlockMockRecorder struct {
	mock *MockBlock
}

// NewMockBlock creates a new mock instance.
func NewMockBlock(ctrl *gomock.Controller) *MockBlock {
	mock := &MockBlock{ctrl: ctrl}
	mock.recorder = &MockBlockMockRecorder{mock}
	return mock
}

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

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

// AddResults indicates an expected call of AddResults.
func (mr *MockBlockMockRecorder) AddResults(resultsByVolumeType interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddResults", reflect.TypeOf((*MockBlock)(nil).AddResults), resultsByVolumeType)
}

// AggregateIter mocks base method.
func (m *MockBlock) AggregateIter(ctx context.Context, aggOpts AggregateResultsOptions) (AggregateIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AggregateIter", ctx, aggOpts)
	ret0, _ := ret[0].(AggregateIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AggregateIter indicates an expected call of AggregateIter.
func (mr *MockBlockMockRecorder) AggregateIter(ctx, aggOpts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregateIter", reflect.TypeOf((*MockBlock)(nil).AggregateIter), ctx, aggOpts)
}

// AggregateWithIter mocks base method.
func (m *MockBlock) AggregateWithIter(ctx context.Context, iter AggregateIterator, opts QueryOptions, results AggregateResults, deadline time.Time, logFields []log.Field) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AggregateWithIter", ctx, iter, opts, results, deadline, logFields)
	ret0, _ := ret[0].(error)
	return ret0
}

// AggregateWithIter indicates an expected call of AggregateWithIter.
func (mr *MockBlockMockRecorder) AggregateWithIter(ctx, iter, opts, results, deadline, logFields interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AggregateWithIter", reflect.TypeOf((*MockBlock)(nil).AggregateWithIter), ctx, iter, opts, results, deadline, logFields)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// MemorySegmentsData mocks base method.
func (m *MockBlock) MemorySegmentsData(ctx context.Context) ([]fst.SegmentData, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MemorySegmentsData", ctx)
	ret0, _ := ret[0].([]fst.SegmentData)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MemorySegmentsData indicates an expected call of MemorySegmentsData.
func (mr *MockBlockMockRecorder) MemorySegmentsData(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MemorySegmentsData", reflect.TypeOf((*MockBlock)(nil).MemorySegmentsData), ctx)
}

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

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

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

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

// QueryIter mocks base method.
func (m *MockBlock) QueryIter(ctx context.Context, query Query) (QueryIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryIter", ctx, query)
	ret0, _ := ret[0].(QueryIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// QueryIter indicates an expected call of QueryIter.
func (mr *MockBlockMockRecorder) QueryIter(ctx, query interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryIter", reflect.TypeOf((*MockBlock)(nil).QueryIter), ctx, query)
}

// QueryWithIter mocks base method.
func (m *MockBlock) QueryWithIter(ctx context.Context, opts QueryOptions, iter QueryIterator, results DocumentResults, deadline time.Time, logFields []log.Field) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "QueryWithIter", ctx, opts, iter, results, deadline, logFields)
	ret0, _ := ret[0].(error)
	return ret0
}

// QueryWithIter indicates an expected call of QueryWithIter.
func (mr *MockBlockMockRecorder) QueryWithIter(ctx, opts, iter, results, deadline, logFields interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "QueryWithIter", reflect.TypeOf((*MockBlock)(nil).QueryWithIter), ctx, opts, iter, results, deadline, logFields)
}

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

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

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

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

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

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

// Stats indicates an expected call of Stats.
func (mr *MockBlockMockRecorder) Stats(reporter interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stats", reflect.TypeOf((*MockBlock)(nil).Stats), reporter)
}

// Tick mocks base method.
func (m *MockBlock) Tick(c context.Cancellable) (BlockTickResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Tick", c)
	ret0, _ := ret[0].(BlockTickResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

// WriteBatch indicates an expected call of WriteBatch.
func (mr *MockBlockMockRecorder) WriteBatch(inserts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteBatch", reflect.TypeOf((*MockBlock)(nil).WriteBatch), inserts)
}

// MockBlockStatsReporter is a mock of BlockStatsReporter interface.
type MockBlockStatsReporter struct {
	ctrl     *gomock.Controller
	recorder *MockBlockStatsReporterMockRecorder
}

// MockBlockStatsReporterMockRecorder is the mock recorder for MockBlockStatsReporter.
type MockBlockStatsReporterMockRecorder struct {
	mock *MockBlockStatsReporter
}

// NewMockBlockStatsReporter creates a new mock instance.
func NewMockBlockStatsReporter(ctrl *gomock.Controller) *MockBlockStatsReporter {
	mock := &MockBlockStatsReporter{ctrl: ctrl}
	mock.recorder = &MockBlockStatsReporterMockRecorder{mock}
	return mock
}

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

// ReportIndexingStats mocks base method.
func (m *MockBlockStatsReporter) ReportIndexingStats(stats BlockIndexingStats) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReportIndexingStats", stats)
}

// ReportIndexingStats indicates an expected call of ReportIndexingStats.
func (mr *MockBlockStatsReporterMockRecorder) ReportIndexingStats(stats interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportIndexingStats", reflect.TypeOf((*MockBlockStatsReporter)(nil).ReportIndexingStats), stats)
}

// ReportSegmentStats mocks base method.
func (m *MockBlockStatsReporter) ReportSegmentStats(stats BlockSegmentStats) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ReportSegmentStats", stats)
}

// ReportSegmentStats indicates an expected call of ReportSegmentStats.
func (mr *MockBlockStatsReporterMockRecorder) ReportSegmentStats(stats interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReportSegmentStats", reflect.TypeOf((*MockBlockStatsReporter)(nil).ReportSegmentStats), stats)
}

// MockQueryIterator is a mock of QueryIterator interface.
type MockQueryIterator struct {
	ctrl     *gomock.Controller
	recorder *MockQueryIteratorMockRecorder
}

// MockQueryIteratorMockRecorder is the mock recorder for MockQueryIterator.
type MockQueryIteratorMockRecorder struct {
	mock *MockQueryIterator
}

// NewMockQueryIterator creates a new mock instance.
func NewMockQueryIterator(ctrl *gomock.Controller) *MockQueryIterator {
	mock := &MockQueryIterator{ctrl: ctrl}
	mock.recorder = &MockQueryIteratorMockRecorder{mock}
	return mock
}

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

// AddDocs mocks base method.
func (m *MockQueryIterator) AddDocs(count int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddDocs", count)
}

// AddDocs indicates an expected call of AddDocs.
func (mr *MockQueryIteratorMockRecorder) AddDocs(count interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDocs", reflect.TypeOf((*MockQueryIterator)(nil).AddDocs), count)
}

// AddSeries mocks base method.
func (m *MockQueryIterator) AddSeries(count int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddSeries", count)
}

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

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

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

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

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

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

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

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

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

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

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

// MockAggregateIterator is a mock of AggregateIterator interface.
type MockAggregateIterator struct {
	ctrl     *gomock.Controller
	recorder *MockAggregateIteratorMockRecorder
}

// MockAggregateIteratorMockRecorder is the mock recorder for MockAggregateIterator.
type MockAggregateIteratorMockRecorder struct {
	mock *MockAggregateIterator
}

// NewMockAggregateIterator creates a new mock instance.
func NewMockAggregateIterator(ctrl *gomock.Controller) *MockAggregateIterator {
	mock := &MockAggregateIterator{ctrl: ctrl}
	mock.recorder = &MockAggregateIteratorMockRecorder{mock}
	return mock
}

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

// AddDocs mocks base method.
func (m *MockAggregateIterator) AddDocs(count int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddDocs", count)
}

// AddDocs indicates an expected call of AddDocs.
func (mr *MockAggregateIteratorMockRecorder) AddDocs(count interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDocs", reflect.TypeOf((*MockAggregateIterator)(nil).AddDocs), count)
}

// AddSeries mocks base method.
func (m *MockAggregateIterator) AddSeries(count int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddSeries", count)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockResultIterator is a mock of ResultIterator interface.
type MockResultIterator struct {
	ctrl     *gomock.Controller
	recorder *MockResultIteratorMockRecorder
}

// MockResultIteratorMockRecorder is the mock recorder for MockResultIterator.
type MockResultIteratorMockRecorder struct {
	mock *MockResultIterator
}

// NewMockResultIterator creates a new mock instance.
func NewMockResultIterator(ctrl *gomock.Controller) *MockResultIterator {
	mock := &MockResultIterator{ctrl: ctrl}
	mock.recorder = &MockResultIteratorMockRecorder{mock}
	return mock
}

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

// AddDocs mocks base method.
func (m *MockResultIterator) AddDocs(count int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddDocs", count)
}

// AddDocs indicates an expected call of AddDocs.
func (mr *MockResultIteratorMockRecorder) AddDocs(count interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDocs", reflect.TypeOf((*MockResultIterator)(nil).AddDocs), count)
}

// AddSeries mocks base method.
func (m *MockResultIterator) AddSeries(count int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddSeries", count)
}

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

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

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

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

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

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

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

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

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

// MockfieldsAndTermsIterator is a mock of fieldsAndTermsIterator interface.
type MockfieldsAndTermsIterator struct {
	ctrl     *gomock.Controller
	recorder *MockfieldsAndTermsIteratorMockRecorder
}

// MockfieldsAndTermsIteratorMockRecorder is the mock recorder for MockfieldsAndTermsIterator.
type MockfieldsAndTermsIteratorMockRecorder struct {
	mock *MockfieldsAndTermsIterator
}

// NewMockfieldsAndTermsIterator creates a new mock instance.
func NewMockfieldsAndTermsIterator(ctrl *gomock.Controller) *MockfieldsAndTermsIterator {
	mock := &MockfieldsAndTermsIterator{ctrl: ctrl}
	mock.recorder = &MockfieldsAndTermsIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetCheckedBytesPool indicates an expected call of SetCheckedBytesPool.
func (mr *MockOptionsMockRecorder) SetCheckedBytesPool(value interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCheckedBytesPool", reflect.TypeOf((*MockOptions)(nil).SetCheckedBytesPool), 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)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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