segment_mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/m3db/m3/src/m3ninx/index/segment/types.go

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

import (
	"reflect"

	"github.com/m3db/m3/src/m3ninx/doc"
	"github.com/m3db/m3/src/m3ninx/index"
	"github.com/m3db/m3/src/m3ninx/postings"

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

// MockSegment is a mock of Segment interface
type MockSegment struct {
	ctrl     *gomock.Controller
	recorder *MockSegmentMockRecorder
}

// MockSegmentMockRecorder is the mock recorder for MockSegment
type MockSegmentMockRecorder struct {
	mock *MockSegment
}

// NewMockSegment creates a new mock instance
func NewMockSegment(ctrl *gomock.Controller) *MockSegment {
	mock := &MockSegment{ctrl: ctrl}
	mock.recorder = &MockSegmentMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

// ContainsID indicates an expected call of ContainsID
func (mr *MockSegmentMockRecorder) ContainsID(docID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsID", reflect.TypeOf((*MockSegment)(nil).ContainsID), docID)
}

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

// ContainsField indicates an expected call of ContainsField
func (mr *MockSegmentMockRecorder) ContainsField(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsField", reflect.TypeOf((*MockSegment)(nil).ContainsField), field)
}

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

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

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

// MockReader is a mock of Reader interface
type MockReader struct {
	ctrl     *gomock.Controller
	recorder *MockReaderMockRecorder
}

// MockReaderMockRecorder is the mock recorder for MockReader
type MockReaderMockRecorder struct {
	mock *MockReader
}

// NewMockReader creates a new mock instance
func NewMockReader(ctrl *gomock.Controller) *MockReader {
	mock := &MockReader{ctrl: ctrl}
	mock.recorder = &MockReaderMockRecorder{mock}
	return mock
}

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

// Doc mocks base method
func (m *MockReader) Doc(id postings.ID) (doc.Document, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Doc", id)
	ret0, _ := ret[0].(doc.Document)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// MatchField mocks base method
func (m *MockReader) MatchField(field []byte) (postings.List, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MatchField", field)
	ret0, _ := ret[0].(postings.List)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MatchField indicates an expected call of MatchField
func (mr *MockReaderMockRecorder) MatchField(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatchField", reflect.TypeOf((*MockReader)(nil).MatchField), field)
}

// MatchTerm mocks base method
func (m *MockReader) MatchTerm(field, term []byte) (postings.List, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MatchTerm", field, term)
	ret0, _ := ret[0].(postings.List)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// MatchTerm indicates an expected call of MatchTerm
func (mr *MockReaderMockRecorder) MatchTerm(field, term interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MatchTerm", reflect.TypeOf((*MockReader)(nil).MatchTerm), field, term)
}

// MatchRegexp mocks base method
func (m *MockReader) MatchRegexp(field []byte, c index.CompiledRegex) (postings.List, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MatchRegexp", field, c)
	ret0, _ := ret[0].(postings.List)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// Docs mocks base method
func (m *MockReader) Docs(pl postings.List) (doc.Iterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Docs", pl)
	ret0, _ := ret[0].(doc.Iterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Docs indicates an expected call of Docs
func (mr *MockReaderMockRecorder) Docs(pl interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Docs", reflect.TypeOf((*MockReader)(nil).Docs), pl)
}

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

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

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

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

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

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

// Terms indicates an expected call of Terms
func (mr *MockReaderMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockReader)(nil).Terms), field)
}

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

// ContainsField indicates an expected call of ContainsField
func (mr *MockReaderMockRecorder) ContainsField(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsField", reflect.TypeOf((*MockReader)(nil).ContainsField), field)
}

// MockFieldsIterable is a mock of FieldsIterable interface
type MockFieldsIterable struct {
	ctrl     *gomock.Controller
	recorder *MockFieldsIterableMockRecorder
}

// MockFieldsIterableMockRecorder is the mock recorder for MockFieldsIterable
type MockFieldsIterableMockRecorder struct {
	mock *MockFieldsIterable
}

// NewMockFieldsIterable creates a new mock instance
func NewMockFieldsIterable(ctrl *gomock.Controller) *MockFieldsIterable {
	mock := &MockFieldsIterable{ctrl: ctrl}
	mock.recorder = &MockFieldsIterableMockRecorder{mock}
	return mock
}

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

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

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

// MockFieldsPostingsListIterable is a mock of FieldsPostingsListIterable interface
type MockFieldsPostingsListIterable struct {
	ctrl     *gomock.Controller
	recorder *MockFieldsPostingsListIterableMockRecorder
}

// MockFieldsPostingsListIterableMockRecorder is the mock recorder for MockFieldsPostingsListIterable
type MockFieldsPostingsListIterableMockRecorder struct {
	mock *MockFieldsPostingsListIterable
}

// NewMockFieldsPostingsListIterable creates a new mock instance
func NewMockFieldsPostingsListIterable(ctrl *gomock.Controller) *MockFieldsPostingsListIterable {
	mock := &MockFieldsPostingsListIterable{ctrl: ctrl}
	mock.recorder = &MockFieldsPostingsListIterableMockRecorder{mock}
	return mock
}

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

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

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

// MockTermsIterable is a mock of TermsIterable interface
type MockTermsIterable struct {
	ctrl     *gomock.Controller
	recorder *MockTermsIterableMockRecorder
}

// MockTermsIterableMockRecorder is the mock recorder for MockTermsIterable
type MockTermsIterableMockRecorder struct {
	mock *MockTermsIterable
}

// NewMockTermsIterable creates a new mock instance
func NewMockTermsIterable(ctrl *gomock.Controller) *MockTermsIterable {
	mock := &MockTermsIterable{ctrl: ctrl}
	mock.recorder = &MockTermsIterableMockRecorder{mock}
	return mock
}

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

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

// Terms indicates an expected call of Terms
func (mr *MockTermsIterableMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockTermsIterable)(nil).Terms), field)
}

// MockOrderedBytesIterator is a mock of OrderedBytesIterator interface
type MockOrderedBytesIterator struct {
	ctrl     *gomock.Controller
	recorder *MockOrderedBytesIteratorMockRecorder
}

// MockOrderedBytesIteratorMockRecorder is the mock recorder for MockOrderedBytesIterator
type MockOrderedBytesIteratorMockRecorder struct {
	mock *MockOrderedBytesIterator
}

// NewMockOrderedBytesIterator creates a new mock instance
func NewMockOrderedBytesIterator(ctrl *gomock.Controller) *MockOrderedBytesIterator {
	mock := &MockOrderedBytesIterator{ctrl: ctrl}
	mock.recorder = &MockOrderedBytesIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// MockFieldsPostingsListIterator is a mock of FieldsPostingsListIterator interface
type MockFieldsPostingsListIterator struct {
	ctrl     *gomock.Controller
	recorder *MockFieldsPostingsListIteratorMockRecorder
}

// MockFieldsPostingsListIteratorMockRecorder is the mock recorder for MockFieldsPostingsListIterator
type MockFieldsPostingsListIteratorMockRecorder struct {
	mock *MockFieldsPostingsListIterator
}

// NewMockFieldsPostingsListIterator creates a new mock instance
func NewMockFieldsPostingsListIterator(ctrl *gomock.Controller) *MockFieldsPostingsListIterator {
	mock := &MockFieldsPostingsListIterator{ctrl: ctrl}
	mock.recorder = &MockFieldsPostingsListIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// MockFieldsIterator is a mock of FieldsIterator interface
type MockFieldsIterator struct {
	ctrl     *gomock.Controller
	recorder *MockFieldsIteratorMockRecorder
}

// MockFieldsIteratorMockRecorder is the mock recorder for MockFieldsIterator
type MockFieldsIteratorMockRecorder struct {
	mock *MockFieldsIterator
}

// NewMockFieldsIterator creates a new mock instance
func NewMockFieldsIterator(ctrl *gomock.Controller) *MockFieldsIterator {
	mock := &MockFieldsIterator{ctrl: ctrl}
	mock.recorder = &MockFieldsIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// MockTermsIterator is a mock of TermsIterator interface
type MockTermsIterator struct {
	ctrl     *gomock.Controller
	recorder *MockTermsIteratorMockRecorder
}

// MockTermsIteratorMockRecorder is the mock recorder for MockTermsIterator
type MockTermsIteratorMockRecorder struct {
	mock *MockTermsIterator
}

// NewMockTermsIterator creates a new mock instance
func NewMockTermsIterator(ctrl *gomock.Controller) *MockTermsIterator {
	mock := &MockTermsIterator{ctrl: ctrl}
	mock.recorder = &MockTermsIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// MockIterator is a mock of Iterator interface
type MockIterator struct {
	ctrl     *gomock.Controller
	recorder *MockIteratorMockRecorder
}

// MockIteratorMockRecorder is the mock recorder for MockIterator
type MockIteratorMockRecorder struct {
	mock *MockIterator
}

// NewMockIterator creates a new mock instance
func NewMockIterator(ctrl *gomock.Controller) *MockIterator {
	mock := &MockIterator{ctrl: ctrl}
	mock.recorder = &MockIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

// MockMutableSegment is a mock of MutableSegment interface
type MockMutableSegment struct {
	ctrl     *gomock.Controller
	recorder *MockMutableSegmentMockRecorder
}

// MockMutableSegmentMockRecorder is the mock recorder for MockMutableSegment
type MockMutableSegmentMockRecorder struct {
	mock *MockMutableSegment
}

// NewMockMutableSegment creates a new mock instance
func NewMockMutableSegment(ctrl *gomock.Controller) *MockMutableSegment {
	mock := &MockMutableSegment{ctrl: ctrl}
	mock.recorder = &MockMutableSegmentMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

// ContainsID indicates an expected call of ContainsID
func (mr *MockMutableSegmentMockRecorder) ContainsID(docID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsID", reflect.TypeOf((*MockMutableSegment)(nil).ContainsID), docID)
}

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

// ContainsField indicates an expected call of ContainsField
func (mr *MockMutableSegmentMockRecorder) ContainsField(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsField", reflect.TypeOf((*MockMutableSegment)(nil).ContainsField), field)
}

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

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

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

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

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

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

// Terms indicates an expected call of Terms
func (mr *MockMutableSegmentMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockMutableSegment)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockMutableSegment) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

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

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

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

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

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

// Insert mocks base method
func (m *MockMutableSegment) Insert(d doc.Document) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", d)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SetIndexConcurrency mocks base method
func (m *MockMutableSegment) SetIndexConcurrency(value int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetIndexConcurrency", value)
}

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

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

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

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

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

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

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

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

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

// MockImmutableSegment is a mock of ImmutableSegment interface
type MockImmutableSegment struct {
	ctrl     *gomock.Controller
	recorder *MockImmutableSegmentMockRecorder
}

// MockImmutableSegmentMockRecorder is the mock recorder for MockImmutableSegment
type MockImmutableSegmentMockRecorder struct {
	mock *MockImmutableSegment
}

// NewMockImmutableSegment creates a new mock instance
func NewMockImmutableSegment(ctrl *gomock.Controller) *MockImmutableSegment {
	mock := &MockImmutableSegment{ctrl: ctrl}
	mock.recorder = &MockImmutableSegmentMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

// ContainsID indicates an expected call of ContainsID
func (mr *MockImmutableSegmentMockRecorder) ContainsID(docID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsID", reflect.TypeOf((*MockImmutableSegment)(nil).ContainsID), docID)
}

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

// ContainsField indicates an expected call of ContainsField
func (mr *MockImmutableSegmentMockRecorder) ContainsField(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ContainsField", reflect.TypeOf((*MockImmutableSegment)(nil).ContainsField), field)
}

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

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

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

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

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

// MockBuilder is a mock of Builder interface
type MockBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockBuilderMockRecorder
}

// MockBuilderMockRecorder is the mock recorder for MockBuilder
type MockBuilderMockRecorder struct {
	mock *MockBuilder
}

// NewMockBuilder creates a new mock instance
func NewMockBuilder(ctrl *gomock.Controller) *MockBuilder {
	mock := &MockBuilder{ctrl: ctrl}
	mock.recorder = &MockBuilderMockRecorder{mock}
	return mock
}

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

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

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

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

// Terms indicates an expected call of Terms
func (mr *MockBuilderMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockBuilder)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockBuilder) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

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

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

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

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

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

// MockDocumentsBuilder is a mock of DocumentsBuilder interface
type MockDocumentsBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockDocumentsBuilderMockRecorder
}

// MockDocumentsBuilderMockRecorder is the mock recorder for MockDocumentsBuilder
type MockDocumentsBuilderMockRecorder struct {
	mock *MockDocumentsBuilder
}

// NewMockDocumentsBuilder creates a new mock instance
func NewMockDocumentsBuilder(ctrl *gomock.Controller) *MockDocumentsBuilder {
	mock := &MockDocumentsBuilder{ctrl: ctrl}
	mock.recorder = &MockDocumentsBuilderMockRecorder{mock}
	return mock
}

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

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

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

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

// Terms indicates an expected call of Terms
func (mr *MockDocumentsBuilderMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockDocumentsBuilder)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockDocumentsBuilder) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

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

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

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

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

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

// Insert mocks base method
func (m *MockDocumentsBuilder) Insert(d doc.Document) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", d)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SetIndexConcurrency mocks base method
func (m *MockDocumentsBuilder) SetIndexConcurrency(value int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetIndexConcurrency", value)
}

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

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

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

// MockCloseableDocumentsBuilder is a mock of CloseableDocumentsBuilder interface
type MockCloseableDocumentsBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockCloseableDocumentsBuilderMockRecorder
}

// MockCloseableDocumentsBuilderMockRecorder is the mock recorder for MockCloseableDocumentsBuilder
type MockCloseableDocumentsBuilderMockRecorder struct {
	mock *MockCloseableDocumentsBuilder
}

// NewMockCloseableDocumentsBuilder creates a new mock instance
func NewMockCloseableDocumentsBuilder(ctrl *gomock.Controller) *MockCloseableDocumentsBuilder {
	mock := &MockCloseableDocumentsBuilder{ctrl: ctrl}
	mock.recorder = &MockCloseableDocumentsBuilderMockRecorder{mock}
	return mock
}

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

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

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

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

// Terms indicates an expected call of Terms
func (mr *MockCloseableDocumentsBuilderMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockCloseableDocumentsBuilder)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockCloseableDocumentsBuilder) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

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

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

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

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

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

// Insert mocks base method
func (m *MockCloseableDocumentsBuilder) Insert(d doc.Document) ([]byte, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Insert", d)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// SetIndexConcurrency mocks base method
func (m *MockCloseableDocumentsBuilder) SetIndexConcurrency(value int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetIndexConcurrency", value)
}

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

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

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

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

// MockSegmentsBuilder is a mock of SegmentsBuilder interface
type MockSegmentsBuilder struct {
	ctrl     *gomock.Controller
	recorder *MockSegmentsBuilderMockRecorder
}

// MockSegmentsBuilderMockRecorder is the mock recorder for MockSegmentsBuilder
type MockSegmentsBuilderMockRecorder struct {
	mock *MockSegmentsBuilder
}

// NewMockSegmentsBuilder creates a new mock instance
func NewMockSegmentsBuilder(ctrl *gomock.Controller) *MockSegmentsBuilder {
	mock := &MockSegmentsBuilder{ctrl: ctrl}
	mock.recorder = &MockSegmentsBuilderMockRecorder{mock}
	return mock
}

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

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

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

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

// Terms indicates an expected call of Terms
func (mr *MockSegmentsBuilderMockRecorder) Terms(field interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Terms", reflect.TypeOf((*MockSegmentsBuilder)(nil).Terms), field)
}

// Reset mocks base method
func (m *MockSegmentsBuilder) Reset(offset postings.ID) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Reset", offset)
}

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

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

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

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

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

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

// AddSegments indicates an expected call of AddSegments
func (mr *MockSegmentsBuilderMockRecorder) AddSegments(segments interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddSegments", reflect.TypeOf((*MockSegmentsBuilder)(nil).AddSegments), segments)
}