mocks.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/sv-tools/mongoifc (interfaces: ChangeStream,Client,Collection,Cursor,Database,IndexView,Session,SingleResult,SessionContext)

// Package mocks is a generated GoMock package.
package mocks

import (
	context "context"
	reflect "reflect"
	time "time"

	gomock "github.com/golang/mock/gomock"
	mongoifc "github.com/sv-tools/mongoifc"
	bson "go.mongodb.org/mongo-driver/bson"
	primitive "go.mongodb.org/mongo-driver/bson/primitive"
	mongo "go.mongodb.org/mongo-driver/mongo"
	options "go.mongodb.org/mongo-driver/mongo/options"
	readconcern "go.mongodb.org/mongo-driver/mongo/readconcern"
	readpref "go.mongodb.org/mongo-driver/mongo/readpref"
	writeconcern "go.mongodb.org/mongo-driver/mongo/writeconcern"
)

// MockChangeStream is a mock of ChangeStream interface.
type MockChangeStream struct {
	ctrl     *gomock.Controller
	recorder *MockChangeStreamMockRecorder
}

// MockChangeStreamMockRecorder is the mock recorder for MockChangeStream.
type MockChangeStreamMockRecorder struct {
	mock *MockChangeStream
}

// NewMockChangeStream creates a new mock instance.
func NewMockChangeStream(ctrl *gomock.Controller) *MockChangeStream {
	mock := &MockChangeStream{ctrl: ctrl}
	mock.recorder = &MockChangeStreamMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Database mocks base method.
func (m *MockClient) Database(arg0 string, arg1 ...*options.DatabaseOptions) mongoifc.Database {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Database", varargs...)
	ret0, _ := ret[0].(mongoifc.Database)
	return ret0
}

// Database indicates an expected call of Database.
func (mr *MockClientMockRecorder) Database(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Database", reflect.TypeOf((*MockClient)(nil).Database), varargs...)
}

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

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

// ListDatabaseNames mocks base method.
func (m *MockClient) ListDatabaseNames(arg0 context.Context, arg1 interface{}, arg2 ...*options.ListDatabasesOptions) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDatabaseNames", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDatabaseNames indicates an expected call of ListDatabaseNames.
func (mr *MockClientMockRecorder) ListDatabaseNames(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabaseNames", reflect.TypeOf((*MockClient)(nil).ListDatabaseNames), varargs...)
}

// ListDatabases mocks base method.
func (m *MockClient) ListDatabases(arg0 context.Context, arg1 interface{}, arg2 ...*options.ListDatabasesOptions) (mongo.ListDatabasesResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListDatabases", varargs...)
	ret0, _ := ret[0].(mongo.ListDatabasesResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListDatabases indicates an expected call of ListDatabases.
func (mr *MockClientMockRecorder) ListDatabases(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabases", reflect.TypeOf((*MockClient)(nil).ListDatabases), varargs...)
}

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

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

// Ping mocks base method.
func (m *MockClient) Ping(arg0 context.Context, arg1 *readpref.ReadPref) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Ping", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// StartSession mocks base method.
func (m *MockClient) StartSession(arg0 ...*options.SessionOptions) (mongoifc.Session, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartSession", varargs...)
	ret0, _ := ret[0].(mongoifc.Session)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// UseSession mocks base method.
func (m *MockClient) UseSession(arg0 context.Context, arg1 func(mongoifc.SessionContext) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UseSession", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// UseSessionWithOptions mocks base method.
func (m *MockClient) UseSessionWithOptions(arg0 context.Context, arg1 *options.SessionOptions, arg2 func(mongoifc.SessionContext) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UseSessionWithOptions", arg0, arg1, arg2)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// Watch mocks base method.
func (m *MockClient) Watch(arg0 context.Context, arg1 interface{}, arg2 ...*options.ChangeStreamOptions) (mongoifc.ChangeStream, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Watch", varargs...)
	ret0, _ := ret[0].(mongoifc.ChangeStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Watch indicates an expected call of Watch.
func (mr *MockClientMockRecorder) Watch(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockClient)(nil).Watch), varargs...)
}

// MockCollection is a mock of Collection interface.
type MockCollection struct {
	ctrl     *gomock.Controller
	recorder *MockCollectionMockRecorder
}

// MockCollectionMockRecorder is the mock recorder for MockCollection.
type MockCollectionMockRecorder struct {
	mock *MockCollection
}

// NewMockCollection creates a new mock instance.
func NewMockCollection(ctrl *gomock.Controller) *MockCollection {
	mock := &MockCollection{ctrl: ctrl}
	mock.recorder = &MockCollectionMockRecorder{mock}
	return mock
}

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

// Aggregate mocks base method.
func (m *MockCollection) Aggregate(arg0 context.Context, arg1 interface{}, arg2 ...*options.AggregateOptions) (mongoifc.Cursor, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Aggregate", varargs...)
	ret0, _ := ret[0].(mongoifc.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Aggregate indicates an expected call of Aggregate.
func (mr *MockCollectionMockRecorder) Aggregate(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockCollection)(nil).Aggregate), varargs...)
}

// BulkWrite mocks base method.
func (m *MockCollection) BulkWrite(arg0 context.Context, arg1 []mongo.WriteModel, arg2 ...*options.BulkWriteOptions) (*mongo.BulkWriteResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BulkWrite", varargs...)
	ret0, _ := ret[0].(*mongo.BulkWriteResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BulkWrite indicates an expected call of BulkWrite.
func (mr *MockCollectionMockRecorder) BulkWrite(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkWrite", reflect.TypeOf((*MockCollection)(nil).BulkWrite), varargs...)
}

// Clone mocks base method.
func (m *MockCollection) Clone(arg0 ...*options.CollectionOptions) (mongoifc.Collection, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Clone", varargs...)
	ret0, _ := ret[0].(mongoifc.Collection)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CountDocuments mocks base method.
func (m *MockCollection) CountDocuments(arg0 context.Context, arg1 interface{}, arg2 ...*options.CountOptions) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CountDocuments", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CountDocuments indicates an expected call of CountDocuments.
func (mr *MockCollectionMockRecorder) CountDocuments(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountDocuments", reflect.TypeOf((*MockCollection)(nil).CountDocuments), varargs...)
}

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

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

// DeleteMany mocks base method.
func (m *MockCollection) DeleteMany(arg0 context.Context, arg1 interface{}, arg2 ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMany", varargs...)
	ret0, _ := ret[0].(*mongo.DeleteResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMany indicates an expected call of DeleteMany.
func (mr *MockCollectionMockRecorder) DeleteMany(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMany", reflect.TypeOf((*MockCollection)(nil).DeleteMany), varargs...)
}

// DeleteOne mocks base method.
func (m *MockCollection) DeleteOne(arg0 context.Context, arg1 interface{}, arg2 ...*options.DeleteOptions) (*mongo.DeleteResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteOne", varargs...)
	ret0, _ := ret[0].(*mongo.DeleteResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOne indicates an expected call of DeleteOne.
func (mr *MockCollectionMockRecorder) DeleteOne(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOne", reflect.TypeOf((*MockCollection)(nil).DeleteOne), varargs...)
}

// Distinct mocks base method.
func (m *MockCollection) Distinct(arg0 context.Context, arg1 string, arg2 interface{}, arg3 ...*options.DistinctOptions) ([]interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Distinct", varargs...)
	ret0, _ := ret[0].([]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Distinct indicates an expected call of Distinct.
func (mr *MockCollectionMockRecorder) Distinct(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Distinct", reflect.TypeOf((*MockCollection)(nil).Distinct), varargs...)
}

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

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

// EstimatedDocumentCount mocks base method.
func (m *MockCollection) EstimatedDocumentCount(arg0 context.Context, arg1 ...*options.EstimatedDocumentCountOptions) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EstimatedDocumentCount", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// EstimatedDocumentCount indicates an expected call of EstimatedDocumentCount.
func (mr *MockCollectionMockRecorder) EstimatedDocumentCount(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EstimatedDocumentCount", reflect.TypeOf((*MockCollection)(nil).EstimatedDocumentCount), varargs...)
}

// Find mocks base method.
func (m *MockCollection) Find(arg0 context.Context, arg1 interface{}, arg2 ...*options.FindOptions) (mongoifc.Cursor, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Find", varargs...)
	ret0, _ := ret[0].(mongoifc.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find.
func (mr *MockCollectionMockRecorder) Find(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockCollection)(nil).Find), varargs...)
}

// FindOne mocks base method.
func (m *MockCollection) FindOne(arg0 context.Context, arg1 interface{}, arg2 ...*options.FindOneOptions) mongoifc.SingleResult {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOne", varargs...)
	ret0, _ := ret[0].(mongoifc.SingleResult)
	return ret0
}

// FindOne indicates an expected call of FindOne.
func (mr *MockCollectionMockRecorder) FindOne(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockCollection)(nil).FindOne), varargs...)
}

// FindOneAndDelete mocks base method.
func (m *MockCollection) FindOneAndDelete(arg0 context.Context, arg1 interface{}, arg2 ...*options.FindOneAndDeleteOptions) mongoifc.SingleResult {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOneAndDelete", varargs...)
	ret0, _ := ret[0].(mongoifc.SingleResult)
	return ret0
}

// FindOneAndDelete indicates an expected call of FindOneAndDelete.
func (mr *MockCollectionMockRecorder) FindOneAndDelete(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneAndDelete", reflect.TypeOf((*MockCollection)(nil).FindOneAndDelete), varargs...)
}

// FindOneAndReplace mocks base method.
func (m *MockCollection) FindOneAndReplace(arg0 context.Context, arg1, arg2 interface{}, arg3 ...*options.FindOneAndReplaceOptions) mongoifc.SingleResult {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOneAndReplace", varargs...)
	ret0, _ := ret[0].(mongoifc.SingleResult)
	return ret0
}

// FindOneAndReplace indicates an expected call of FindOneAndReplace.
func (mr *MockCollectionMockRecorder) FindOneAndReplace(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneAndReplace", reflect.TypeOf((*MockCollection)(nil).FindOneAndReplace), varargs...)
}

// FindOneAndUpdate mocks base method.
func (m *MockCollection) FindOneAndUpdate(arg0 context.Context, arg1, arg2 interface{}, arg3 ...*options.FindOneAndUpdateOptions) mongoifc.SingleResult {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOneAndUpdate", varargs...)
	ret0, _ := ret[0].(mongoifc.SingleResult)
	return ret0
}

// FindOneAndUpdate indicates an expected call of FindOneAndUpdate.
func (mr *MockCollectionMockRecorder) FindOneAndUpdate(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneAndUpdate", reflect.TypeOf((*MockCollection)(nil).FindOneAndUpdate), varargs...)
}

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

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

// InsertMany mocks base method.
func (m *MockCollection) InsertMany(arg0 context.Context, arg1 []interface{}, arg2 ...*options.InsertManyOptions) (*mongo.InsertManyResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "InsertMany", varargs...)
	ret0, _ := ret[0].(*mongo.InsertManyResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertMany indicates an expected call of InsertMany.
func (mr *MockCollectionMockRecorder) InsertMany(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMany", reflect.TypeOf((*MockCollection)(nil).InsertMany), varargs...)
}

// InsertOne mocks base method.
func (m *MockCollection) InsertOne(arg0 context.Context, arg1 interface{}, arg2 ...*options.InsertOneOptions) (*mongo.InsertOneResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "InsertOne", varargs...)
	ret0, _ := ret[0].(*mongo.InsertOneResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOne indicates an expected call of InsertOne.
func (mr *MockCollectionMockRecorder) InsertOne(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOne", reflect.TypeOf((*MockCollection)(nil).InsertOne), varargs...)
}

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

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

// ReplaceOne mocks base method.
func (m *MockCollection) ReplaceOne(arg0 context.Context, arg1, arg2 interface{}, arg3 ...*options.ReplaceOptions) (*mongo.UpdateResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceOne", varargs...)
	ret0, _ := ret[0].(*mongo.UpdateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceOne indicates an expected call of ReplaceOne.
func (mr *MockCollectionMockRecorder) ReplaceOne(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceOne", reflect.TypeOf((*MockCollection)(nil).ReplaceOne), varargs...)
}

// UpdateByID mocks base method.
func (m *MockCollection) UpdateByID(arg0 context.Context, arg1, arg2 interface{}, arg3 ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateByID", varargs...)
	ret0, _ := ret[0].(*mongo.UpdateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateByID indicates an expected call of UpdateByID.
func (mr *MockCollectionMockRecorder) UpdateByID(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateByID", reflect.TypeOf((*MockCollection)(nil).UpdateByID), varargs...)
}

// UpdateMany mocks base method.
func (m *MockCollection) UpdateMany(arg0 context.Context, arg1, arg2 interface{}, arg3 ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateMany", varargs...)
	ret0, _ := ret[0].(*mongo.UpdateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMany indicates an expected call of UpdateMany.
func (mr *MockCollectionMockRecorder) UpdateMany(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMany", reflect.TypeOf((*MockCollection)(nil).UpdateMany), varargs...)
}

// UpdateOne mocks base method.
func (m *MockCollection) UpdateOne(arg0 context.Context, arg1, arg2 interface{}, arg3 ...*options.UpdateOptions) (*mongo.UpdateResult, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2}
	for _, a := range arg3 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateOne", varargs...)
	ret0, _ := ret[0].(*mongo.UpdateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOne indicates an expected call of UpdateOne.
func (mr *MockCollectionMockRecorder) UpdateOne(arg0, arg1, arg2 interface{}, arg3 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2}, arg3...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOne", reflect.TypeOf((*MockCollection)(nil).UpdateOne), varargs...)
}

// Watch mocks base method.
func (m *MockCollection) Watch(arg0 context.Context, arg1 interface{}, arg2 ...*options.ChangeStreamOptions) (mongoifc.ChangeStream, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Watch", varargs...)
	ret0, _ := ret[0].(mongoifc.ChangeStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Watch indicates an expected call of Watch.
func (mr *MockCollectionMockRecorder) Watch(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockCollection)(nil).Watch), varargs...)
}

// MockCursor is a mock of Cursor interface.
type MockCursor struct {
	ctrl     *gomock.Controller
	recorder *MockCursorMockRecorder
}

// MockCursorMockRecorder is the mock recorder for MockCursor.
type MockCursorMockRecorder struct {
	mock *MockCursor
}

// NewMockCursor creates a new mock instance.
func NewMockCursor(ctrl *gomock.Controller) *MockCursor {
	mock := &MockCursor{ctrl: ctrl}
	mock.recorder = &MockCursorMockRecorder{mock}
	return mock
}

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

// All mocks base method.
func (m *MockCursor) All(arg0 context.Context, arg1 interface{}) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockDatabase is a mock of Database interface.
type MockDatabase struct {
	ctrl     *gomock.Controller
	recorder *MockDatabaseMockRecorder
}

// MockDatabaseMockRecorder is the mock recorder for MockDatabase.
type MockDatabaseMockRecorder struct {
	mock *MockDatabase
}

// NewMockDatabase creates a new mock instance.
func NewMockDatabase(ctrl *gomock.Controller) *MockDatabase {
	mock := &MockDatabase{ctrl: ctrl}
	mock.recorder = &MockDatabaseMockRecorder{mock}
	return mock
}

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

// Aggregate mocks base method.
func (m *MockDatabase) Aggregate(arg0 context.Context, arg1 interface{}, arg2 ...*options.AggregateOptions) (mongoifc.Cursor, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Aggregate", varargs...)
	ret0, _ := ret[0].(mongoifc.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Aggregate indicates an expected call of Aggregate.
func (mr *MockDatabaseMockRecorder) Aggregate(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockDatabase)(nil).Aggregate), varargs...)
}

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

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

// Collection mocks base method.
func (m *MockDatabase) Collection(arg0 string, arg1 ...*options.CollectionOptions) mongoifc.Collection {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Collection", varargs...)
	ret0, _ := ret[0].(mongoifc.Collection)
	return ret0
}

// Collection indicates an expected call of Collection.
func (mr *MockDatabaseMockRecorder) Collection(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Collection", reflect.TypeOf((*MockDatabase)(nil).Collection), varargs...)
}

// CreateCollection mocks base method.
func (m *MockDatabase) CreateCollection(arg0 context.Context, arg1 string, arg2 ...*options.CreateCollectionOptions) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateCollection", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateCollection indicates an expected call of CreateCollection.
func (mr *MockDatabaseMockRecorder) CreateCollection(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCollection", reflect.TypeOf((*MockDatabase)(nil).CreateCollection), varargs...)
}

// CreateView mocks base method.
func (m *MockDatabase) CreateView(arg0 context.Context, arg1, arg2 string, arg3 interface{}, arg4 ...*options.CreateViewOptions) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1, arg2, arg3}
	for _, a := range arg4 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateView", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateView indicates an expected call of CreateView.
func (mr *MockDatabaseMockRecorder) CreateView(arg0, arg1, arg2, arg3 interface{}, arg4 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1, arg2, arg3}, arg4...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateView", reflect.TypeOf((*MockDatabase)(nil).CreateView), varargs...)
}

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

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

// ListCollectionNames mocks base method.
func (m *MockDatabase) ListCollectionNames(arg0 context.Context, arg1 interface{}, arg2 ...*options.ListCollectionsOptions) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCollectionNames", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCollectionNames indicates an expected call of ListCollectionNames.
func (mr *MockDatabaseMockRecorder) ListCollectionNames(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCollectionNames", reflect.TypeOf((*MockDatabase)(nil).ListCollectionNames), varargs...)
}

// ListCollectionSpecifications mocks base method.
func (m *MockDatabase) ListCollectionSpecifications(arg0 context.Context, arg1 interface{}, arg2 ...*options.ListCollectionsOptions) ([]*mongo.CollectionSpecification, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCollectionSpecifications", varargs...)
	ret0, _ := ret[0].([]*mongo.CollectionSpecification)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCollectionSpecifications indicates an expected call of ListCollectionSpecifications.
func (mr *MockDatabaseMockRecorder) ListCollectionSpecifications(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCollectionSpecifications", reflect.TypeOf((*MockDatabase)(nil).ListCollectionSpecifications), varargs...)
}

// ListCollections mocks base method.
func (m *MockDatabase) ListCollections(arg0 context.Context, arg1 interface{}, arg2 ...*options.ListCollectionsOptions) (mongoifc.Cursor, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListCollections", varargs...)
	ret0, _ := ret[0].(mongoifc.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListCollections indicates an expected call of ListCollections.
func (mr *MockDatabaseMockRecorder) ListCollections(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCollections", reflect.TypeOf((*MockDatabase)(nil).ListCollections), varargs...)
}

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

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

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

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

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

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

// RunCommand mocks base method.
func (m *MockDatabase) RunCommand(arg0 context.Context, arg1 interface{}, arg2 ...*options.RunCmdOptions) mongoifc.SingleResult {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunCommand", varargs...)
	ret0, _ := ret[0].(mongoifc.SingleResult)
	return ret0
}

// RunCommand indicates an expected call of RunCommand.
func (mr *MockDatabaseMockRecorder) RunCommand(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunCommand", reflect.TypeOf((*MockDatabase)(nil).RunCommand), varargs...)
}

// RunCommandCursor mocks base method.
func (m *MockDatabase) RunCommandCursor(arg0 context.Context, arg1 interface{}, arg2 ...*options.RunCmdOptions) (mongoifc.Cursor, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunCommandCursor", varargs...)
	ret0, _ := ret[0].(mongoifc.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RunCommandCursor indicates an expected call of RunCommandCursor.
func (mr *MockDatabaseMockRecorder) RunCommandCursor(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunCommandCursor", reflect.TypeOf((*MockDatabase)(nil).RunCommandCursor), varargs...)
}

// Watch mocks base method.
func (m *MockDatabase) Watch(arg0 context.Context, arg1 interface{}, arg2 ...*options.ChangeStreamOptions) (mongoifc.ChangeStream, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Watch", varargs...)
	ret0, _ := ret[0].(mongoifc.ChangeStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Watch indicates an expected call of Watch.
func (mr *MockDatabaseMockRecorder) Watch(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockDatabase)(nil).Watch), varargs...)
}

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

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

// MockIndexView is a mock of IndexView interface.
type MockIndexView struct {
	ctrl     *gomock.Controller
	recorder *MockIndexViewMockRecorder
}

// MockIndexViewMockRecorder is the mock recorder for MockIndexView.
type MockIndexViewMockRecorder struct {
	mock *MockIndexView
}

// NewMockIndexView creates a new mock instance.
func NewMockIndexView(ctrl *gomock.Controller) *MockIndexView {
	mock := &MockIndexView{ctrl: ctrl}
	mock.recorder = &MockIndexViewMockRecorder{mock}
	return mock
}

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

// CreateMany mocks base method.
func (m *MockIndexView) CreateMany(arg0 context.Context, arg1 []mongo.IndexModel, arg2 ...*options.CreateIndexesOptions) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateMany", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateMany indicates an expected call of CreateMany.
func (mr *MockIndexViewMockRecorder) CreateMany(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateMany", reflect.TypeOf((*MockIndexView)(nil).CreateMany), varargs...)
}

// CreateOne mocks base method.
func (m *MockIndexView) CreateOne(arg0 context.Context, arg1 mongo.IndexModel, arg2 ...*options.CreateIndexesOptions) (string, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateOne", varargs...)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateOne indicates an expected call of CreateOne.
func (mr *MockIndexViewMockRecorder) CreateOne(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOne", reflect.TypeOf((*MockIndexView)(nil).CreateOne), varargs...)
}

// DropAll mocks base method.
func (m *MockIndexView) DropAll(arg0 context.Context, arg1 ...*options.DropIndexesOptions) (bson.Raw, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DropAll", varargs...)
	ret0, _ := ret[0].(bson.Raw)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DropAll indicates an expected call of DropAll.
func (mr *MockIndexViewMockRecorder) DropAll(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropAll", reflect.TypeOf((*MockIndexView)(nil).DropAll), varargs...)
}

// DropOne mocks base method.
func (m *MockIndexView) DropOne(arg0 context.Context, arg1 string, arg2 ...*options.DropIndexesOptions) (bson.Raw, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DropOne", varargs...)
	ret0, _ := ret[0].(bson.Raw)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DropOne indicates an expected call of DropOne.
func (mr *MockIndexViewMockRecorder) DropOne(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropOne", reflect.TypeOf((*MockIndexView)(nil).DropOne), varargs...)
}

// List mocks base method.
func (m *MockIndexView) List(arg0 context.Context, arg1 ...*options.ListIndexesOptions) (mongoifc.Cursor, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "List", varargs...)
	ret0, _ := ret[0].(mongoifc.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// List indicates an expected call of List.
func (mr *MockIndexViewMockRecorder) List(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockIndexView)(nil).List), varargs...)
}

// ListSpecifications mocks base method.
func (m *MockIndexView) ListSpecifications(arg0 context.Context, arg1 ...*options.ListIndexesOptions) ([]*mongo.IndexSpecification, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListSpecifications", varargs...)
	ret0, _ := ret[0].([]*mongo.IndexSpecification)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListSpecifications indicates an expected call of ListSpecifications.
func (mr *MockIndexViewMockRecorder) ListSpecifications(arg0 interface{}, arg1 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListSpecifications", reflect.TypeOf((*MockIndexView)(nil).ListSpecifications), varargs...)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// EndSession mocks base method.
func (m *MockSession) EndSession(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EndSession", arg0)
}

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

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

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

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

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

// StartTransaction mocks base method.
func (m *MockSession) StartTransaction(arg0 ...*options.TransactionOptions) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartTransaction", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// WithTransaction mocks base method.
func (m *MockSession) WithTransaction(arg0 context.Context, arg1 func(mongoifc.SessionContext) (interface{}, error), arg2 ...*options.TransactionOptions) (interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WithTransaction", varargs...)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WithTransaction indicates an expected call of WithTransaction.
func (mr *MockSessionMockRecorder) WithTransaction(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTransaction", reflect.TypeOf((*MockSession)(nil).WithTransaction), varargs...)
}

// MockSingleResult is a mock of SingleResult interface.
type MockSingleResult struct {
	ctrl     *gomock.Controller
	recorder *MockSingleResultMockRecorder
}

// MockSingleResultMockRecorder is the mock recorder for MockSingleResult.
type MockSingleResultMockRecorder struct {
	mock *MockSingleResult
}

// NewMockSingleResult creates a new mock instance.
func NewMockSingleResult(ctrl *gomock.Controller) *MockSingleResult {
	mock := &MockSingleResult{ctrl: ctrl}
	mock.recorder = &MockSingleResultMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

// MockSessionContext is a mock of SessionContext interface.
type MockSessionContext struct {
	ctrl     *gomock.Controller
	recorder *MockSessionContextMockRecorder
}

// MockSessionContextMockRecorder is the mock recorder for MockSessionContext.
type MockSessionContextMockRecorder struct {
	mock *MockSessionContext
}

// NewMockSessionContext creates a new mock instance.
func NewMockSessionContext(ctrl *gomock.Controller) *MockSessionContext {
	mock := &MockSessionContext{ctrl: ctrl}
	mock.recorder = &MockSessionContextMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// EndSession mocks base method.
func (m *MockSessionContext) EndSession(arg0 context.Context) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "EndSession", arg0)
}

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

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

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

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

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

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

// StartTransaction mocks base method.
func (m *MockSessionContext) StartTransaction(arg0 ...*options.TransactionOptions) error {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "StartTransaction", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// WithTransaction mocks base method.
func (m *MockSessionContext) WithTransaction(arg0 context.Context, arg1 func(mongoifc.SessionContext) (interface{}, error), arg2 ...*options.TransactionOptions) (interface{}, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{arg0, arg1}
	for _, a := range arg2 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WithTransaction", varargs...)
	ret0, _ := ret[0].(interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WithTransaction indicates an expected call of WithTransaction.
func (mr *MockSessionContextMockRecorder) WithTransaction(arg0, arg1 interface{}, arg2 ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{arg0, arg1}, arg2...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTransaction", reflect.TypeOf((*MockSessionContext)(nil).WithTransaction), varargs...)
}