github.com/m3db/m3@v1.5.0/src/dbnode/client/client_mock.go

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

import (
	"context"
	"reflect"
	"time"

	"github.com/m3db/m3/src/dbnode/encoding"
	"github.com/m3db/m3/src/dbnode/generated/thrift/rpc"
	"github.com/m3db/m3/src/dbnode/namespace"
	"github.com/m3db/m3/src/dbnode/runtime"
	"github.com/m3db/m3/src/dbnode/storage/block"
	"github.com/m3db/m3/src/dbnode/storage/bootstrap/result"
	"github.com/m3db/m3/src/dbnode/storage/index"
	"github.com/m3db/m3/src/dbnode/topology"
	"github.com/m3db/m3/src/x/clock"
	context0 "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/pool"
	"github.com/m3db/m3/src/x/retry"
	"github.com/m3db/m3/src/x/sampler"
	"github.com/m3db/m3/src/x/serialize"
	"github.com/m3db/m3/src/x/sync"
	time0 "github.com/m3db/m3/src/x/time"

	"github.com/golang/mock/gomock"
	tchannel_go "github.com/uber/tchannel-go"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

// MockSession is a mock of Session interface.
type MockSession struct {
	ctrl     *gomock.Controller
	recorder *MockSessionMockRecorder
}

// MockSessionMockRecorder is the mock recorder for MockSession.
type MockSessionMockRecorder struct {
	mock *MockSession
}

// NewMockSession creates a new mock instance.
func NewMockSession(ctrl *gomock.Controller) *MockSession {
	mock := &MockSession{ctrl: ctrl}
	mock.recorder = &MockSessionMockRecorder{mock}
	return mock
}

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

// Aggregate mocks base method.
func (m *MockSession) Aggregate(ctx context.Context, namespace ident.ID, q index.Query, opts index.AggregationOptions) (AggregatedTagsIterator, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Aggregate", ctx, namespace, q, opts)
	ret0, _ := ret[0].(AggregatedTagsIterator)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Aggregate indicates an expected call of Aggregate.
func (mr *MockSessionMockRecorder) Aggregate(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockSession)(nil).Aggregate), ctx, namespace, q, opts)
}

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

// Fetch mocks base method.
func (m *MockSession) Fetch(namespace, id ident.ID, startInclusive, endExclusive time0.UnixNano) (encoding.SeriesIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fetch", namespace, id, startInclusive, endExclusive)
	ret0, _ := ret[0].(encoding.SeriesIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fetch indicates an expected call of Fetch.
func (mr *MockSessionMockRecorder) Fetch(namespace, id, startInclusive, endExclusive interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockSession)(nil).Fetch), namespace, id, startInclusive, endExclusive)
}

// FetchIDs mocks base method.
func (m *MockSession) FetchIDs(namespace ident.ID, ids ident.Iterator, startInclusive, endExclusive time0.UnixNano) (encoding.SeriesIterators, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchIDs", namespace, ids, startInclusive, endExclusive)
	ret0, _ := ret[0].(encoding.SeriesIterators)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchIDs indicates an expected call of FetchIDs.
func (mr *MockSessionMockRecorder) FetchIDs(namespace, ids, startInclusive, endExclusive interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchIDs", reflect.TypeOf((*MockSession)(nil).FetchIDs), namespace, ids, startInclusive, endExclusive)
}

// FetchTagged mocks base method.
func (m *MockSession) FetchTagged(ctx context.Context, namespace ident.ID, q index.Query, opts index.QueryOptions) (encoding.SeriesIterators, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchTagged", ctx, namespace, q, opts)
	ret0, _ := ret[0].(encoding.SeriesIterators)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchTagged indicates an expected call of FetchTagged.
func (mr *MockSessionMockRecorder) FetchTagged(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTagged", reflect.TypeOf((*MockSession)(nil).FetchTagged), ctx, namespace, q, opts)
}

// FetchTaggedIDs mocks base method.
func (m *MockSession) FetchTaggedIDs(ctx context.Context, namespace ident.ID, q index.Query, opts index.QueryOptions) (TaggedIDsIterator, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchTaggedIDs", ctx, namespace, q, opts)
	ret0, _ := ret[0].(TaggedIDsIterator)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchTaggedIDs indicates an expected call of FetchTaggedIDs.
func (mr *MockSessionMockRecorder) FetchTaggedIDs(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaggedIDs", reflect.TypeOf((*MockSession)(nil).FetchTaggedIDs), ctx, namespace, q, opts)
}

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

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

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

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

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

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

// Write mocks base method.
func (m *MockSession) Write(namespace, id ident.ID, t time0.UnixNano, value float64, unit time0.Unit, annotation []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", namespace, id, t, value, unit, annotation)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockSessionMockRecorder) Write(namespace, id, t, value, unit, annotation interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockSession)(nil).Write), namespace, id, t, value, unit, annotation)
}

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

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

// WriteTagged mocks base method.
func (m *MockSession) WriteTagged(namespace, id ident.ID, tags ident.TagIterator, t time0.UnixNano, value float64, unit time0.Unit, annotation []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteTagged", namespace, id, tags, t, value, unit, annotation)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteTagged indicates an expected call of WriteTagged.
func (mr *MockSessionMockRecorder) WriteTagged(namespace, id, tags, t, value, unit, annotation interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockSession)(nil).WriteTagged), namespace, id, tags, t, value, unit, annotation)
}

// MockAggregatedTagsIterator is a mock of AggregatedTagsIterator interface.
type MockAggregatedTagsIterator struct {
	ctrl     *gomock.Controller
	recorder *MockAggregatedTagsIteratorMockRecorder
}

// MockAggregatedTagsIteratorMockRecorder is the mock recorder for MockAggregatedTagsIterator.
type MockAggregatedTagsIteratorMockRecorder struct {
	mock *MockAggregatedTagsIterator
}

// NewMockAggregatedTagsIterator creates a new mock instance.
func NewMockAggregatedTagsIterator(ctrl *gomock.Controller) *MockAggregatedTagsIterator {
	mock := &MockAggregatedTagsIterator{ctrl: ctrl}
	mock.recorder = &MockAggregatedTagsIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockTaggedIDsIterator is a mock of TaggedIDsIterator interface.
type MockTaggedIDsIterator struct {
	ctrl     *gomock.Controller
	recorder *MockTaggedIDsIteratorMockRecorder
}

// MockTaggedIDsIteratorMockRecorder is the mock recorder for MockTaggedIDsIterator.
type MockTaggedIDsIteratorMockRecorder struct {
	mock *MockTaggedIDsIterator
}

// NewMockTaggedIDsIterator creates a new mock instance.
func NewMockTaggedIDsIterator(ctrl *gomock.Controller) *MockTaggedIDsIterator {
	mock := &MockTaggedIDsIterator{ctrl: ctrl}
	mock.recorder = &MockTaggedIDsIteratorMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

// MockAdminClient is a mock of AdminClient interface.
type MockAdminClient struct {
	ctrl     *gomock.Controller
	recorder *MockAdminClientMockRecorder
}

// MockAdminClientMockRecorder is the mock recorder for MockAdminClient.
type MockAdminClientMockRecorder struct {
	mock *MockAdminClient
}

// NewMockAdminClient creates a new mock instance.
func NewMockAdminClient(ctrl *gomock.Controller) *MockAdminClient {
	mock := &MockAdminClient{ctrl: ctrl}
	mock.recorder = &MockAdminClientMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockPeerBlockMetadataIter is a mock of PeerBlockMetadataIter interface.
type MockPeerBlockMetadataIter struct {
	ctrl     *gomock.Controller
	recorder *MockPeerBlockMetadataIterMockRecorder
}

// MockPeerBlockMetadataIterMockRecorder is the mock recorder for MockPeerBlockMetadataIter.
type MockPeerBlockMetadataIterMockRecorder struct {
	mock *MockPeerBlockMetadataIter
}

// NewMockPeerBlockMetadataIter creates a new mock instance.
func NewMockPeerBlockMetadataIter(ctrl *gomock.Controller) *MockPeerBlockMetadataIter {
	mock := &MockPeerBlockMetadataIter{ctrl: ctrl}
	mock.recorder = &MockPeerBlockMetadataIterMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockPeerBlocksIter is a mock of PeerBlocksIter interface.
type MockPeerBlocksIter struct {
	ctrl     *gomock.Controller
	recorder *MockPeerBlocksIterMockRecorder
}

// MockPeerBlocksIterMockRecorder is the mock recorder for MockPeerBlocksIter.
type MockPeerBlocksIterMockRecorder struct {
	mock *MockPeerBlocksIter
}

// NewMockPeerBlocksIter creates a new mock instance.
func NewMockPeerBlocksIter(ctrl *gomock.Controller) *MockPeerBlocksIter {
	mock := &MockPeerBlocksIter{ctrl: ctrl}
	mock.recorder = &MockPeerBlocksIterMockRecorder{mock}
	return mock
}

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

// Current mocks base method.
func (m *MockPeerBlocksIter) Current() (topology.Host, ident.ID, ident.Tags, block.DatabaseBlock) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Current")
	ret0, _ := ret[0].(topology.Host)
	ret1, _ := ret[1].(ident.ID)
	ret2, _ := ret[2].(ident.Tags)
	ret3, _ := ret[3].(block.DatabaseBlock)
	return ret0, ret1, ret2, ret3
}

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

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

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

// MockAdminSession is a mock of AdminSession interface.
type MockAdminSession struct {
	ctrl     *gomock.Controller
	recorder *MockAdminSessionMockRecorder
}

// MockAdminSessionMockRecorder is the mock recorder for MockAdminSession.
type MockAdminSessionMockRecorder struct {
	mock *MockAdminSession
}

// NewMockAdminSession creates a new mock instance.
func NewMockAdminSession(ctrl *gomock.Controller) *MockAdminSession {
	mock := &MockAdminSession{ctrl: ctrl}
	mock.recorder = &MockAdminSessionMockRecorder{mock}
	return mock
}

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

// Aggregate mocks base method.
func (m *MockAdminSession) Aggregate(ctx context.Context, namespace ident.ID, q index.Query, opts index.AggregationOptions) (AggregatedTagsIterator, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Aggregate", ctx, namespace, q, opts)
	ret0, _ := ret[0].(AggregatedTagsIterator)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Aggregate indicates an expected call of Aggregate.
func (mr *MockAdminSessionMockRecorder) Aggregate(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockAdminSession)(nil).Aggregate), ctx, namespace, q, opts)
}

// BorrowConnections mocks base method.
func (m *MockAdminSession) BorrowConnections(shardID uint32, fn WithBorrowConnectionFn, opts BorrowConnectionOptions) (BorrowConnectionsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BorrowConnections", shardID, fn, opts)
	ret0, _ := ret[0].(BorrowConnectionsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BorrowConnections indicates an expected call of BorrowConnections.
func (mr *MockAdminSessionMockRecorder) BorrowConnections(shardID, fn, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BorrowConnections", reflect.TypeOf((*MockAdminSession)(nil).BorrowConnections), shardID, fn, opts)
}

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

// DedicatedConnection mocks base method.
func (m *MockAdminSession) DedicatedConnection(shardID uint32, opts DedicatedConnectionOptions) (rpc.TChanNode, Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DedicatedConnection", shardID, opts)
	ret0, _ := ret[0].(rpc.TChanNode)
	ret1, _ := ret[1].(Channel)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DedicatedConnection indicates an expected call of DedicatedConnection.
func (mr *MockAdminSessionMockRecorder) DedicatedConnection(shardID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DedicatedConnection", reflect.TypeOf((*MockAdminSession)(nil).DedicatedConnection), shardID, opts)
}

// Fetch mocks base method.
func (m *MockAdminSession) Fetch(namespace, id ident.ID, startInclusive, endExclusive time0.UnixNano) (encoding.SeriesIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fetch", namespace, id, startInclusive, endExclusive)
	ret0, _ := ret[0].(encoding.SeriesIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fetch indicates an expected call of Fetch.
func (mr *MockAdminSessionMockRecorder) Fetch(namespace, id, startInclusive, endExclusive interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockAdminSession)(nil).Fetch), namespace, id, startInclusive, endExclusive)
}

// FetchBlocksFromPeers mocks base method.
func (m *MockAdminSession) FetchBlocksFromPeers(namespace namespace.Metadata, shard uint32, consistencyLevel topology.ReadConsistencyLevel, metadatas []block.ReplicaMetadata, opts result.Options) (PeerBlocksIter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBlocksFromPeers", namespace, shard, consistencyLevel, metadatas, opts)
	ret0, _ := ret[0].(PeerBlocksIter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBlocksFromPeers indicates an expected call of FetchBlocksFromPeers.
func (mr *MockAdminSessionMockRecorder) FetchBlocksFromPeers(namespace, shard, consistencyLevel, metadatas, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksFromPeers", reflect.TypeOf((*MockAdminSession)(nil).FetchBlocksFromPeers), namespace, shard, consistencyLevel, metadatas, opts)
}

// FetchBlocksMetadataFromPeers mocks base method.
func (m *MockAdminSession) FetchBlocksMetadataFromPeers(namespace ident.ID, shard uint32, start, end time0.UnixNano, consistencyLevel topology.ReadConsistencyLevel, result result.Options) (PeerBlockMetadataIter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBlocksMetadataFromPeers", namespace, shard, start, end, consistencyLevel, result)
	ret0, _ := ret[0].(PeerBlockMetadataIter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBlocksMetadataFromPeers indicates an expected call of FetchBlocksMetadataFromPeers.
func (mr *MockAdminSessionMockRecorder) FetchBlocksMetadataFromPeers(namespace, shard, start, end, consistencyLevel, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksMetadataFromPeers", reflect.TypeOf((*MockAdminSession)(nil).FetchBlocksMetadataFromPeers), namespace, shard, start, end, consistencyLevel, result)
}

// FetchBootstrapBlocksFromPeers mocks base method.
func (m *MockAdminSession) FetchBootstrapBlocksFromPeers(namespace namespace.Metadata, shard uint32, start, end time0.UnixNano, opts result.Options) (result.ShardResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBootstrapBlocksFromPeers", namespace, shard, start, end, opts)
	ret0, _ := ret[0].(result.ShardResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBootstrapBlocksFromPeers indicates an expected call of FetchBootstrapBlocksFromPeers.
func (mr *MockAdminSessionMockRecorder) FetchBootstrapBlocksFromPeers(namespace, shard, start, end, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBootstrapBlocksFromPeers", reflect.TypeOf((*MockAdminSession)(nil).FetchBootstrapBlocksFromPeers), namespace, shard, start, end, opts)
}

// FetchBootstrapBlocksMetadataFromPeers mocks base method.
func (m *MockAdminSession) FetchBootstrapBlocksMetadataFromPeers(namespace ident.ID, shard uint32, start, end time0.UnixNano, result result.Options) (PeerBlockMetadataIter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBootstrapBlocksMetadataFromPeers", namespace, shard, start, end, result)
	ret0, _ := ret[0].(PeerBlockMetadataIter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBootstrapBlocksMetadataFromPeers indicates an expected call of FetchBootstrapBlocksMetadataFromPeers.
func (mr *MockAdminSessionMockRecorder) FetchBootstrapBlocksMetadataFromPeers(namespace, shard, start, end, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBootstrapBlocksMetadataFromPeers", reflect.TypeOf((*MockAdminSession)(nil).FetchBootstrapBlocksMetadataFromPeers), namespace, shard, start, end, result)
}

// FetchIDs mocks base method.
func (m *MockAdminSession) FetchIDs(namespace ident.ID, ids ident.Iterator, startInclusive, endExclusive time0.UnixNano) (encoding.SeriesIterators, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchIDs", namespace, ids, startInclusive, endExclusive)
	ret0, _ := ret[0].(encoding.SeriesIterators)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchIDs indicates an expected call of FetchIDs.
func (mr *MockAdminSessionMockRecorder) FetchIDs(namespace, ids, startInclusive, endExclusive interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchIDs", reflect.TypeOf((*MockAdminSession)(nil).FetchIDs), namespace, ids, startInclusive, endExclusive)
}

// FetchTagged mocks base method.
func (m *MockAdminSession) FetchTagged(ctx context.Context, namespace ident.ID, q index.Query, opts index.QueryOptions) (encoding.SeriesIterators, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchTagged", ctx, namespace, q, opts)
	ret0, _ := ret[0].(encoding.SeriesIterators)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchTagged indicates an expected call of FetchTagged.
func (mr *MockAdminSessionMockRecorder) FetchTagged(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTagged", reflect.TypeOf((*MockAdminSession)(nil).FetchTagged), ctx, namespace, q, opts)
}

// FetchTaggedIDs mocks base method.
func (m *MockAdminSession) FetchTaggedIDs(ctx context.Context, namespace ident.ID, q index.Query, opts index.QueryOptions) (TaggedIDsIterator, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchTaggedIDs", ctx, namespace, q, opts)
	ret0, _ := ret[0].(TaggedIDsIterator)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchTaggedIDs indicates an expected call of FetchTaggedIDs.
func (mr *MockAdminSessionMockRecorder) FetchTaggedIDs(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaggedIDs", reflect.TypeOf((*MockAdminSession)(nil).FetchTaggedIDs), ctx, namespace, q, opts)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Truncate indicates an expected call of Truncate.
func (mr *MockAdminSessionMockRecorder) Truncate(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockAdminSession)(nil).Truncate), namespace)
}

// Write mocks base method.
func (m *MockAdminSession) Write(namespace, id ident.ID, t time0.UnixNano, value float64, unit time0.Unit, annotation []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", namespace, id, t, value, unit, annotation)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockAdminSessionMockRecorder) Write(namespace, id, t, value, unit, annotation interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockAdminSession)(nil).Write), namespace, id, t, value, unit, annotation)
}

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

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

// WriteTagged mocks base method.
func (m *MockAdminSession) WriteTagged(namespace, id ident.ID, tags ident.TagIterator, t time0.UnixNano, value float64, unit time0.Unit, annotation []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteTagged", namespace, id, tags, t, value, unit, annotation)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteTagged indicates an expected call of WriteTagged.
func (mr *MockAdminSessionMockRecorder) WriteTagged(namespace, id, tags, t, value, unit, annotation interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockAdminSession)(nil).WriteTagged), namespace, id, tags, t, value, unit, annotation)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockAdminOptions is a mock of AdminOptions interface.
type MockAdminOptions struct {
	ctrl     *gomock.Controller
	recorder *MockAdminOptionsMockRecorder
}

// MockAdminOptionsMockRecorder is the mock recorder for MockAdminOptions.
type MockAdminOptionsMockRecorder struct {
	mock *MockAdminOptions
}

// NewMockAdminOptions creates a new mock instance.
func NewMockAdminOptions(ctrl *gomock.Controller) *MockAdminOptions {
	mock := &MockAdminOptions{ctrl: ctrl}
	mock.recorder = &MockAdminOptionsMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetBootstrapConsistencyLevel mocks base method.
func (m *MockAdminOptions) SetBootstrapConsistencyLevel(value topology.ReadConsistencyLevel) AdminOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetBootstrapConsistencyLevel", value)
	ret0, _ := ret[0].(AdminOptions)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetEncodingProto indicates an expected call of SetEncodingProto.
func (mr *MockAdminOptionsMockRecorder) SetEncodingProto(encodingOpts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetEncodingProto", reflect.TypeOf((*MockAdminOptions)(nil).SetEncodingProto), encodingOpts)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetNewConnectionFn mocks base method.
func (m *MockAdminOptions) SetNewConnectionFn(value NewConnectionFn) AdminOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetNewConnectionFn", value)
	ret0, _ := ret[0].(AdminOptions)
	return ret0
}

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

// SetOrigin mocks base method.
func (m *MockAdminOptions) SetOrigin(value topology.Host) AdminOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetOrigin", value)
	ret0, _ := ret[0].(AdminOptions)
	return ret0
}

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

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

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

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

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

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

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

// SetSchemaRegistry mocks base method.
func (m *MockAdminOptions) SetSchemaRegistry(registry namespace.SchemaRegistry) AdminOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetSchemaRegistry", registry)
	ret0, _ := ret[0].(AdminOptions)
	return ret0
}

// SetSchemaRegistry indicates an expected call of SetSchemaRegistry.
func (mr *MockAdminOptionsMockRecorder) SetSchemaRegistry(registry interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetSchemaRegistry", reflect.TypeOf((*MockAdminOptions)(nil).SetSchemaRegistry), registry)
}

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

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

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

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

// SetStreamBlocksRetrier mocks base method.
func (m *MockAdminOptions) SetStreamBlocksRetrier(value retry.Retrier) AdminOptions {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SetStreamBlocksRetrier", value)
	ret0, _ := ret[0].(AdminOptions)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockclientSession is a mock of clientSession interface.
type MockclientSession struct {
	ctrl     *gomock.Controller
	recorder *MockclientSessionMockRecorder
}

// MockclientSessionMockRecorder is the mock recorder for MockclientSession.
type MockclientSessionMockRecorder struct {
	mock *MockclientSession
}

// NewMockclientSession creates a new mock instance.
func NewMockclientSession(ctrl *gomock.Controller) *MockclientSession {
	mock := &MockclientSession{ctrl: ctrl}
	mock.recorder = &MockclientSessionMockRecorder{mock}
	return mock
}

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

// Aggregate mocks base method.
func (m *MockclientSession) Aggregate(ctx context.Context, namespace ident.ID, q index.Query, opts index.AggregationOptions) (AggregatedTagsIterator, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Aggregate", ctx, namespace, q, opts)
	ret0, _ := ret[0].(AggregatedTagsIterator)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// Aggregate indicates an expected call of Aggregate.
func (mr *MockclientSessionMockRecorder) Aggregate(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockclientSession)(nil).Aggregate), ctx, namespace, q, opts)
}

// BorrowConnections mocks base method.
func (m *MockclientSession) BorrowConnections(shardID uint32, fn WithBorrowConnectionFn, opts BorrowConnectionOptions) (BorrowConnectionsResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BorrowConnections", shardID, fn, opts)
	ret0, _ := ret[0].(BorrowConnectionsResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BorrowConnections indicates an expected call of BorrowConnections.
func (mr *MockclientSessionMockRecorder) BorrowConnections(shardID, fn, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BorrowConnections", reflect.TypeOf((*MockclientSession)(nil).BorrowConnections), shardID, fn, opts)
}

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

// DedicatedConnection mocks base method.
func (m *MockclientSession) DedicatedConnection(shardID uint32, opts DedicatedConnectionOptions) (rpc.TChanNode, Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DedicatedConnection", shardID, opts)
	ret0, _ := ret[0].(rpc.TChanNode)
	ret1, _ := ret[1].(Channel)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// DedicatedConnection indicates an expected call of DedicatedConnection.
func (mr *MockclientSessionMockRecorder) DedicatedConnection(shardID, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DedicatedConnection", reflect.TypeOf((*MockclientSession)(nil).DedicatedConnection), shardID, opts)
}

// Fetch mocks base method.
func (m *MockclientSession) Fetch(namespace, id ident.ID, startInclusive, endExclusive time0.UnixNano) (encoding.SeriesIterator, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Fetch", namespace, id, startInclusive, endExclusive)
	ret0, _ := ret[0].(encoding.SeriesIterator)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Fetch indicates an expected call of Fetch.
func (mr *MockclientSessionMockRecorder) Fetch(namespace, id, startInclusive, endExclusive interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Fetch", reflect.TypeOf((*MockclientSession)(nil).Fetch), namespace, id, startInclusive, endExclusive)
}

// FetchBlocksFromPeers mocks base method.
func (m *MockclientSession) FetchBlocksFromPeers(namespace namespace.Metadata, shard uint32, consistencyLevel topology.ReadConsistencyLevel, metadatas []block.ReplicaMetadata, opts result.Options) (PeerBlocksIter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBlocksFromPeers", namespace, shard, consistencyLevel, metadatas, opts)
	ret0, _ := ret[0].(PeerBlocksIter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBlocksFromPeers indicates an expected call of FetchBlocksFromPeers.
func (mr *MockclientSessionMockRecorder) FetchBlocksFromPeers(namespace, shard, consistencyLevel, metadatas, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksFromPeers", reflect.TypeOf((*MockclientSession)(nil).FetchBlocksFromPeers), namespace, shard, consistencyLevel, metadatas, opts)
}

// FetchBlocksMetadataFromPeers mocks base method.
func (m *MockclientSession) FetchBlocksMetadataFromPeers(namespace ident.ID, shard uint32, start, end time0.UnixNano, consistencyLevel topology.ReadConsistencyLevel, result result.Options) (PeerBlockMetadataIter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBlocksMetadataFromPeers", namespace, shard, start, end, consistencyLevel, result)
	ret0, _ := ret[0].(PeerBlockMetadataIter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBlocksMetadataFromPeers indicates an expected call of FetchBlocksMetadataFromPeers.
func (mr *MockclientSessionMockRecorder) FetchBlocksMetadataFromPeers(namespace, shard, start, end, consistencyLevel, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBlocksMetadataFromPeers", reflect.TypeOf((*MockclientSession)(nil).FetchBlocksMetadataFromPeers), namespace, shard, start, end, consistencyLevel, result)
}

// FetchBootstrapBlocksFromPeers mocks base method.
func (m *MockclientSession) FetchBootstrapBlocksFromPeers(namespace namespace.Metadata, shard uint32, start, end time0.UnixNano, opts result.Options) (result.ShardResult, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBootstrapBlocksFromPeers", namespace, shard, start, end, opts)
	ret0, _ := ret[0].(result.ShardResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBootstrapBlocksFromPeers indicates an expected call of FetchBootstrapBlocksFromPeers.
func (mr *MockclientSessionMockRecorder) FetchBootstrapBlocksFromPeers(namespace, shard, start, end, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBootstrapBlocksFromPeers", reflect.TypeOf((*MockclientSession)(nil).FetchBootstrapBlocksFromPeers), namespace, shard, start, end, opts)
}

// FetchBootstrapBlocksMetadataFromPeers mocks base method.
func (m *MockclientSession) FetchBootstrapBlocksMetadataFromPeers(namespace ident.ID, shard uint32, start, end time0.UnixNano, result result.Options) (PeerBlockMetadataIter, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchBootstrapBlocksMetadataFromPeers", namespace, shard, start, end, result)
	ret0, _ := ret[0].(PeerBlockMetadataIter)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchBootstrapBlocksMetadataFromPeers indicates an expected call of FetchBootstrapBlocksMetadataFromPeers.
func (mr *MockclientSessionMockRecorder) FetchBootstrapBlocksMetadataFromPeers(namespace, shard, start, end, result interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchBootstrapBlocksMetadataFromPeers", reflect.TypeOf((*MockclientSession)(nil).FetchBootstrapBlocksMetadataFromPeers), namespace, shard, start, end, result)
}

// FetchIDs mocks base method.
func (m *MockclientSession) FetchIDs(namespace ident.ID, ids ident.Iterator, startInclusive, endExclusive time0.UnixNano) (encoding.SeriesIterators, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchIDs", namespace, ids, startInclusive, endExclusive)
	ret0, _ := ret[0].(encoding.SeriesIterators)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// FetchIDs indicates an expected call of FetchIDs.
func (mr *MockclientSessionMockRecorder) FetchIDs(namespace, ids, startInclusive, endExclusive interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchIDs", reflect.TypeOf((*MockclientSession)(nil).FetchIDs), namespace, ids, startInclusive, endExclusive)
}

// FetchTagged mocks base method.
func (m *MockclientSession) FetchTagged(ctx context.Context, namespace ident.ID, q index.Query, opts index.QueryOptions) (encoding.SeriesIterators, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchTagged", ctx, namespace, q, opts)
	ret0, _ := ret[0].(encoding.SeriesIterators)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchTagged indicates an expected call of FetchTagged.
func (mr *MockclientSessionMockRecorder) FetchTagged(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTagged", reflect.TypeOf((*MockclientSession)(nil).FetchTagged), ctx, namespace, q, opts)
}

// FetchTaggedIDs mocks base method.
func (m *MockclientSession) FetchTaggedIDs(ctx context.Context, namespace ident.ID, q index.Query, opts index.QueryOptions) (TaggedIDsIterator, FetchResponseMetadata, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "FetchTaggedIDs", ctx, namespace, q, opts)
	ret0, _ := ret[0].(TaggedIDsIterator)
	ret1, _ := ret[1].(FetchResponseMetadata)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// FetchTaggedIDs indicates an expected call of FetchTaggedIDs.
func (mr *MockclientSessionMockRecorder) FetchTaggedIDs(ctx, namespace, q, opts interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTaggedIDs", reflect.TypeOf((*MockclientSession)(nil).FetchTaggedIDs), ctx, namespace, q, opts)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Truncate indicates an expected call of Truncate.
func (mr *MockclientSessionMockRecorder) Truncate(namespace interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Truncate", reflect.TypeOf((*MockclientSession)(nil).Truncate), namespace)
}

// Write mocks base method.
func (m *MockclientSession) Write(namespace, id ident.ID, t time0.UnixNano, value float64, unit time0.Unit, annotation []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", namespace, id, t, value, unit, annotation)
	ret0, _ := ret[0].(error)
	return ret0
}

// Write indicates an expected call of Write.
func (mr *MockclientSessionMockRecorder) Write(namespace, id, t, value, unit, annotation interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockclientSession)(nil).Write), namespace, id, t, value, unit, annotation)
}

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

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

// WriteTagged mocks base method.
func (m *MockclientSession) WriteTagged(namespace, id ident.ID, tags ident.TagIterator, t time0.UnixNano, value float64, unit time0.Unit, annotation []byte) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WriteTagged", namespace, id, tags, t, value, unit, annotation)
	ret0, _ := ret[0].(error)
	return ret0
}

// WriteTagged indicates an expected call of WriteTagged.
func (mr *MockclientSessionMockRecorder) WriteTagged(namespace, id, tags, t, value, unit, annotation interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTagged", reflect.TypeOf((*MockclientSession)(nil).WriteTagged), namespace, id, tags, t, value, unit, annotation)
}

// MockhostQueue is a mock of hostQueue interface.
type MockhostQueue struct {
	ctrl     *gomock.Controller
	recorder *MockhostQueueMockRecorder
}

// MockhostQueueMockRecorder is the mock recorder for MockhostQueue.
type MockhostQueueMockRecorder struct {
	mock *MockhostQueue
}

// NewMockhostQueue creates a new mock instance.
func NewMockhostQueue(ctrl *gomock.Controller) *MockhostQueue {
	mock := &MockhostQueue{ctrl: ctrl}
	mock.recorder = &MockhostQueueMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// Enqueue indicates an expected call of Enqueue.
func (mr *MockhostQueueMockRecorder) Enqueue(op interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Enqueue", reflect.TypeOf((*MockhostQueue)(nil).Enqueue), op)
}

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

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

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

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

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

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

// MockChannel is a mock of Channel interface.
type MockChannel struct {
	ctrl     *gomock.Controller
	recorder *MockChannelMockRecorder
}

// MockChannelMockRecorder is the mock recorder for MockChannel.
type MockChannelMockRecorder struct {
	mock *MockChannel
}

// NewMockChannel creates a new mock instance.
func NewMockChannel(ctrl *gomock.Controller) *MockChannel {
	mock := &MockChannel{ctrl: ctrl}
	mock.recorder = &MockChannelMockRecorder{mock}
	return mock
}

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

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

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

// GetSubChannel mocks base method.
func (m *MockChannel) GetSubChannel(serviceName string, opts ...tchannel_go.SubChannelOption) *tchannel_go.SubChannel {
	m.ctrl.T.Helper()
	varargs := []interface{}{serviceName}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSubChannel", varargs...)
	ret0, _ := ret[0].(*tchannel_go.SubChannel)
	return ret0
}

// GetSubChannel indicates an expected call of GetSubChannel.
func (mr *MockChannelMockRecorder) GetSubChannel(serviceName interface{}, opts ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{serviceName}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubChannel", reflect.TypeOf((*MockChannel)(nil).GetSubChannel), varargs...)
}

// MockconnectionPool is a mock of connectionPool interface.
type MockconnectionPool struct {
	ctrl     *gomock.Controller
	recorder *MockconnectionPoolMockRecorder
}

// MockconnectionPoolMockRecorder is the mock recorder for MockconnectionPool.
type MockconnectionPoolMockRecorder struct {
	mock *MockconnectionPool
}

// NewMockconnectionPool creates a new mock instance.
func NewMockconnectionPool(ctrl *gomock.Controller) *MockconnectionPool {
	mock := &MockconnectionPool{ctrl: ctrl}
	mock.recorder = &MockconnectionPoolMockRecorder{mock}
	return mock
}

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

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

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

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

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

// NextClient mocks base method.
func (m *MockconnectionPool) NextClient() (rpc.TChanNode, Channel, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NextClient")
	ret0, _ := ret[0].(rpc.TChanNode)
	ret1, _ := ret[1].(Channel)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

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

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

// MockpeerSource is a mock of peerSource interface.
type MockpeerSource struct {
	ctrl     *gomock.Controller
	recorder *MockpeerSourceMockRecorder
}

// MockpeerSourceMockRecorder is the mock recorder for MockpeerSource.
type MockpeerSourceMockRecorder struct {
	mock *MockpeerSource
}

// NewMockpeerSource creates a new mock instance.
func NewMockpeerSource(ctrl *gomock.Controller) *MockpeerSource {
	mock := &MockpeerSource{ctrl: ctrl}
	mock.recorder = &MockpeerSourceMockRecorder{mock}
	return mock
}

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

// BorrowConnection mocks base method.
func (m *MockpeerSource) BorrowConnection(hostID string, fn WithConnectionFn) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "BorrowConnection", hostID, fn)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Mockpeer is a mock of peer interface.
type Mockpeer struct {
	ctrl     *gomock.Controller
	recorder *MockpeerMockRecorder
}

// MockpeerMockRecorder is the mock recorder for Mockpeer.
type MockpeerMockRecorder struct {
	mock *Mockpeer
}

// NewMockpeer creates a new mock instance.
func NewMockpeer(ctrl *gomock.Controller) *Mockpeer {
	mock := &Mockpeer{ctrl: ctrl}
	mock.recorder = &MockpeerMockRecorder{mock}
	return mock
}

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

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

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

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

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

// Mockop is a mock of op interface.
type Mockop struct {
	ctrl     *gomock.Controller
	recorder *MockopMockRecorder
}

// MockopMockRecorder is the mock recorder for Mockop.
type MockopMockRecorder struct {
	mock *Mockop
}

// NewMockop creates a new mock instance.
func NewMockop(ctrl *gomock.Controller) *Mockop {
	mock := &Mockop{ctrl: ctrl}
	mock.recorder = &MockopMockRecorder{mock}
	return mock
}

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

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

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

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

// MockenqueueChannel is a mock of enqueueChannel interface.
type MockenqueueChannel struct {
	ctrl     *gomock.Controller
	recorder *MockenqueueChannelMockRecorder
}

// MockenqueueChannelMockRecorder is the mock recorder for MockenqueueChannel.
type MockenqueueChannelMockRecorder struct {
	mock *MockenqueueChannel
}

// NewMockenqueueChannel creates a new mock instance.
func NewMockenqueueChannel(ctrl *gomock.Controller) *MockenqueueChannel {
	mock := &MockenqueueChannel{ctrl: ctrl}
	mock.recorder = &MockenqueueChannelMockRecorder{mock}
	return mock
}

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

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

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

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

// enqueue indicates an expected call of enqueue.
func (mr *MockenqueueChannelMockRecorder) enqueue(peersMetadata interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "enqueue", reflect.TypeOf((*MockenqueueChannel)(nil).enqueue), peersMetadata)
}

// enqueueDelayed mocks base method.
func (m *MockenqueueChannel) enqueueDelayed(numToEnqueue int) (enqueueDelayedFn, enqueueDelayedDoneFn, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "enqueueDelayed", numToEnqueue)
	ret0, _ := ret[0].(enqueueDelayedFn)
	ret1, _ := ret[1].(enqueueDelayedDoneFn)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// enqueueDelayed indicates an expected call of enqueueDelayed.
func (mr *MockenqueueChannelMockRecorder) enqueueDelayed(numToEnqueue interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "enqueueDelayed", reflect.TypeOf((*MockenqueueChannel)(nil).enqueueDelayed), numToEnqueue)
}

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

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

// trackPending mocks base method.
func (m *MockenqueueChannel) trackPending(amount int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "trackPending", amount)
}

// trackPending indicates an expected call of trackPending.
func (mr *MockenqueueChannelMockRecorder) trackPending(amount interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "trackPending", reflect.TypeOf((*MockenqueueChannel)(nil).trackPending), amount)
}

// trackProcessed mocks base method.
func (m *MockenqueueChannel) trackProcessed(amount int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "trackProcessed", amount)
}

// trackProcessed indicates an expected call of trackProcessed.
func (mr *MockenqueueChannelMockRecorder) trackProcessed(amount interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "trackProcessed", reflect.TypeOf((*MockenqueueChannel)(nil).trackProcessed), amount)
}

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

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