// Code generated by MockGen. DO NOT EDIT.
// Source: git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/mongo (interfaces: DbCollection,DbClient,SingleResultHelper,Cursor,ChangeStream)
//
// Generated by this command:
//
//	mockgen -destination=../../mocks/lib/mongo/mongo.go git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/mongo DbCollection,DbClient,SingleResultHelper,Cursor,ChangeStream
//

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

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

	mongo "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/mongo"
	bson "go.mongodb.org/mongo-driver/v2/bson"
	mongo0 "go.mongodb.org/mongo-driver/v2/mongo"
	options "go.mongodb.org/mongo-driver/v2/mongo/options"
	readpref "go.mongodb.org/mongo-driver/v2/mongo/readpref"
	gomock "go.uber.org/mock/gomock"
)

// MockDbCollection is a mock of DbCollection interface.
type MockDbCollection struct {
	ctrl     *gomock.Controller
	recorder *MockDbCollectionMockRecorder
	isgomock struct{}
}

// MockDbCollectionMockRecorder is the mock recorder for MockDbCollection.
type MockDbCollectionMockRecorder struct {
	mock *MockDbCollection
}

// NewMockDbCollection creates a new mock instance.
func NewMockDbCollection(ctrl *gomock.Controller) *MockDbCollection {
	mock := &MockDbCollection{ctrl: ctrl}
	mock.recorder = &MockDbCollectionMockRecorder{mock}
	return mock
}

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

// Aggregate mocks base method.
func (m *MockDbCollection) Aggregate(ctx context.Context, pipeline any, opts ...options.Lister[options.AggregateOptions]) (mongo.Cursor, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, pipeline}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Aggregate", varargs...)
	ret0, _ := ret[0].(mongo.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Aggregate indicates an expected call of Aggregate.
func (mr *MockDbCollectionMockRecorder) Aggregate(ctx, pipeline any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, pipeline}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Aggregate", reflect.TypeOf((*MockDbCollection)(nil).Aggregate), varargs...)
}

// BulkWrite mocks base method.
func (m *MockDbCollection) BulkWrite(ctx context.Context, models []mongo0.WriteModel, opts ...options.Lister[options.BulkWriteOptions]) (*mongo0.BulkWriteResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, models}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BulkWrite", varargs...)
	ret0, _ := ret[0].(*mongo0.BulkWriteResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BulkWrite indicates an expected call of BulkWrite.
func (mr *MockDbCollectionMockRecorder) BulkWrite(ctx, models any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, models}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkWrite", reflect.TypeOf((*MockDbCollection)(nil).BulkWrite), varargs...)
}

// CountDocuments mocks base method.
func (m *MockDbCollection) CountDocuments(ctx context.Context, filter any, opts ...options.Lister[options.CountOptions]) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter}
	for _, a := range opts {
		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 *MockDbCollectionMockRecorder) CountDocuments(ctx, filter any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CountDocuments", reflect.TypeOf((*MockDbCollection)(nil).CountDocuments), varargs...)
}

// DeleteMany mocks base method.
func (m *MockDbCollection) DeleteMany(ctx context.Context, filter any, opts ...options.Lister[options.DeleteManyOptions]) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteMany", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteMany indicates an expected call of DeleteMany.
func (mr *MockDbCollectionMockRecorder) DeleteMany(ctx, filter any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteMany", reflect.TypeOf((*MockDbCollection)(nil).DeleteMany), varargs...)
}

// DeleteOne mocks base method.
func (m *MockDbCollection) DeleteOne(ctx context.Context, filter any, opts ...options.Lister[options.DeleteOneOptions]) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteOne", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteOne indicates an expected call of DeleteOne.
func (mr *MockDbCollectionMockRecorder) DeleteOne(ctx, filter any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOne", reflect.TypeOf((*MockDbCollection)(nil).DeleteOne), varargs...)
}

// Distinct mocks base method.
func (m *MockDbCollection) Distinct(ctx context.Context, fieldName string, filter any, opts ...options.Lister[options.DistinctOptions]) *mongo0.DistinctResult {
	m.ctrl.T.Helper()
	varargs := []any{ctx, fieldName, filter}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Distinct", varargs...)
	ret0, _ := ret[0].(*mongo0.DistinctResult)
	return ret0
}

// Distinct indicates an expected call of Distinct.
func (mr *MockDbCollectionMockRecorder) Distinct(ctx, fieldName, filter any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, fieldName, filter}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Distinct", reflect.TypeOf((*MockDbCollection)(nil).Distinct), varargs...)
}

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

// Drop indicates an expected call of Drop.
func (mr *MockDbCollectionMockRecorder) Drop(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Drop", reflect.TypeOf((*MockDbCollection)(nil).Drop), ctx)
}

// Find mocks base method.
func (m *MockDbCollection) Find(ctx context.Context, filter any, opts ...options.Lister[options.FindOptions]) (mongo.Cursor, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Find", varargs...)
	ret0, _ := ret[0].(mongo.Cursor)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Find indicates an expected call of Find.
func (mr *MockDbCollectionMockRecorder) Find(ctx, filter any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Find", reflect.TypeOf((*MockDbCollection)(nil).Find), varargs...)
}

// FindOne mocks base method.
func (m *MockDbCollection) FindOne(ctx context.Context, filter any, opts ...options.Lister[options.FindOneOptions]) mongo.SingleResultHelper {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOne", varargs...)
	ret0, _ := ret[0].(mongo.SingleResultHelper)
	return ret0
}

// FindOne indicates an expected call of FindOne.
func (mr *MockDbCollectionMockRecorder) FindOne(ctx, filter any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOne", reflect.TypeOf((*MockDbCollection)(nil).FindOne), varargs...)
}

// FindOneAndDelete mocks base method.
func (m *MockDbCollection) FindOneAndDelete(ctx context.Context, filter any, opts ...options.Lister[options.FindOneAndDeleteOptions]) mongo.SingleResultHelper {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOneAndDelete", varargs...)
	ret0, _ := ret[0].(mongo.SingleResultHelper)
	return ret0
}

// FindOneAndDelete indicates an expected call of FindOneAndDelete.
func (mr *MockDbCollectionMockRecorder) FindOneAndDelete(ctx, filter any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneAndDelete", reflect.TypeOf((*MockDbCollection)(nil).FindOneAndDelete), varargs...)
}

// FindOneAndReplace mocks base method.
func (m *MockDbCollection) FindOneAndReplace(ctx context.Context, filter, replacement any, opts ...options.Lister[options.FindOneAndReplaceOptions]) mongo.SingleResultHelper {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter, replacement}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOneAndReplace", varargs...)
	ret0, _ := ret[0].(mongo.SingleResultHelper)
	return ret0
}

// FindOneAndReplace indicates an expected call of FindOneAndReplace.
func (mr *MockDbCollectionMockRecorder) FindOneAndReplace(ctx, filter, replacement any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter, replacement}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneAndReplace", reflect.TypeOf((*MockDbCollection)(nil).FindOneAndReplace), varargs...)
}

// FindOneAndUpdate mocks base method.
func (m *MockDbCollection) FindOneAndUpdate(ctx context.Context, filter, update any, opts ...options.Lister[options.FindOneAndUpdateOptions]) mongo.SingleResultHelper {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter, update}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "FindOneAndUpdate", varargs...)
	ret0, _ := ret[0].(mongo.SingleResultHelper)
	return ret0
}

// FindOneAndUpdate indicates an expected call of FindOneAndUpdate.
func (mr *MockDbCollectionMockRecorder) FindOneAndUpdate(ctx, filter, update any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter, update}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FindOneAndUpdate", reflect.TypeOf((*MockDbCollection)(nil).FindOneAndUpdate), varargs...)
}

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

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

// InsertMany mocks base method.
func (m *MockDbCollection) InsertMany(ctx context.Context, documents any, opts ...options.Lister[options.InsertManyOptions]) ([]any, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, documents}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "InsertMany", varargs...)
	ret0, _ := ret[0].([]any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertMany indicates an expected call of InsertMany.
func (mr *MockDbCollectionMockRecorder) InsertMany(ctx, documents any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, documents}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertMany", reflect.TypeOf((*MockDbCollection)(nil).InsertMany), varargs...)
}

// InsertOne mocks base method.
func (m *MockDbCollection) InsertOne(ctx context.Context, document any, opts ...options.Lister[options.InsertOneOptions]) (any, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, document}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "InsertOne", varargs...)
	ret0, _ := ret[0].(any)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InsertOne indicates an expected call of InsertOne.
func (mr *MockDbCollectionMockRecorder) InsertOne(ctx, document any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, document}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertOne", reflect.TypeOf((*MockDbCollection)(nil).InsertOne), varargs...)
}

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

// ReplaceOne mocks base method.
func (m *MockDbCollection) ReplaceOne(ctx context.Context, filter, replacement any, opts ...options.Lister[options.ReplaceOptions]) (*mongo0.UpdateResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter, replacement}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ReplaceOne", varargs...)
	ret0, _ := ret[0].(*mongo0.UpdateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ReplaceOne indicates an expected call of ReplaceOne.
func (mr *MockDbCollectionMockRecorder) ReplaceOne(ctx, filter, replacement any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter, replacement}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReplaceOne", reflect.TypeOf((*MockDbCollection)(nil).ReplaceOne), varargs...)
}

// UpdateMany mocks base method.
func (m *MockDbCollection) UpdateMany(ctx context.Context, filter, update any, opts ...options.Lister[options.UpdateManyOptions]) (*mongo0.UpdateResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter, update}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateMany", varargs...)
	ret0, _ := ret[0].(*mongo0.UpdateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateMany indicates an expected call of UpdateMany.
func (mr *MockDbCollectionMockRecorder) UpdateMany(ctx, filter, update any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter, update}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateMany", reflect.TypeOf((*MockDbCollection)(nil).UpdateMany), varargs...)
}

// UpdateOne mocks base method.
func (m *MockDbCollection) UpdateOne(ctx context.Context, filter, update any, opts ...options.Lister[options.UpdateOneOptions]) (*mongo0.UpdateResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter, update}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "UpdateOne", varargs...)
	ret0, _ := ret[0].(*mongo0.UpdateResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// UpdateOne indicates an expected call of UpdateOne.
func (mr *MockDbCollectionMockRecorder) UpdateOne(ctx, filter, update any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter, update}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateOne", reflect.TypeOf((*MockDbCollection)(nil).UpdateOne), varargs...)
}

// Watch mocks base method.
func (m *MockDbCollection) Watch(ctx context.Context, pipeline any, opts ...options.Lister[options.ChangeStreamOptions]) (mongo.ChangeStream, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, pipeline}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Watch", varargs...)
	ret0, _ := ret[0].(mongo.ChangeStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Watch indicates an expected call of Watch.
func (mr *MockDbCollectionMockRecorder) Watch(ctx, pipeline any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, pipeline}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockDbCollection)(nil).Watch), varargs...)
}

// MockDbClient is a mock of DbClient interface.
type MockDbClient struct {
	ctrl     *gomock.Controller
	recorder *MockDbClientMockRecorder
	isgomock struct{}
}

// MockDbClientMockRecorder is the mock recorder for MockDbClient.
type MockDbClientMockRecorder struct {
	mock *MockDbClient
}

// NewMockDbClient creates a new mock instance.
func NewMockDbClient(ctrl *gomock.Controller) *MockDbClient {
	mock := &MockDbClient{ctrl: ctrl}
	mock.recorder = &MockDbClientMockRecorder{mock}
	return mock
}

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

// BulkWrite mocks base method.
func (m *MockDbClient) BulkWrite(ctx context.Context, writes []mongo0.ClientBulkWrite, opts ...options.Lister[options.ClientBulkWriteOptions]) (*mongo0.ClientBulkWriteResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, writes}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BulkWrite", varargs...)
	ret0, _ := ret[0].(*mongo0.ClientBulkWriteResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BulkWrite indicates an expected call of BulkWrite.
func (mr *MockDbClientMockRecorder) BulkWrite(ctx, writes any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, writes}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BulkWrite", reflect.TypeOf((*MockDbClient)(nil).BulkWrite), varargs...)
}

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

// Collection indicates an expected call of Collection.
func (mr *MockDbClientMockRecorder) Collection(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Collection", reflect.TypeOf((*MockDbClient)(nil).Collection), arg0)
}

// CreateCollection mocks base method.
func (m *MockDbClient) CreateCollection(ctx context.Context, name string, opts ...options.Lister[options.CreateCollectionOptions]) error {
	m.ctrl.T.Helper()
	varargs := []any{ctx, name}
	for _, a := range opts {
		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 *MockDbClientMockRecorder) CreateCollection(ctx, name any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, name}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCollection", reflect.TypeOf((*MockDbClient)(nil).CreateCollection), varargs...)
}

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

// Disconnect indicates an expected call of Disconnect.
func (mr *MockDbClientMockRecorder) Disconnect(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Disconnect", reflect.TypeOf((*MockDbClient)(nil).Disconnect), ctx)
}

// ListCollectionNames mocks base method.
func (m *MockDbClient) ListCollectionNames(ctx context.Context, filter any, opts ...options.Lister[options.ListCollectionsOptions]) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, filter}
	for _, a := range opts {
		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 *MockDbClientMockRecorder) ListCollectionNames(ctx, filter any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, filter}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCollectionNames", reflect.TypeOf((*MockDbClient)(nil).ListCollectionNames), varargs...)
}

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

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

// Ping indicates an expected call of Ping.
func (mr *MockDbClientMockRecorder) Ping(ctx, rp any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockDbClient)(nil).Ping), ctx, rp)
}

// RunAdminCommand mocks base method.
func (m *MockDbClient) RunAdminCommand(ctx context.Context, runCommand any, opts ...options.Lister[options.RunCmdOptions]) mongo.SingleResultHelper {
	m.ctrl.T.Helper()
	varargs := []any{ctx, runCommand}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunAdminCommand", varargs...)
	ret0, _ := ret[0].(mongo.SingleResultHelper)
	return ret0
}

// RunAdminCommand indicates an expected call of RunAdminCommand.
func (mr *MockDbClientMockRecorder) RunAdminCommand(ctx, runCommand any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, runCommand}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunAdminCommand", reflect.TypeOf((*MockDbClient)(nil).RunAdminCommand), varargs...)
}

// RunCommand mocks base method.
func (m *MockDbClient) RunCommand(ctx context.Context, runCommand any, opts ...options.Lister[options.RunCmdOptions]) mongo.SingleResultHelper {
	m.ctrl.T.Helper()
	varargs := []any{ctx, runCommand}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "RunCommand", varargs...)
	ret0, _ := ret[0].(mongo.SingleResultHelper)
	return ret0
}

// RunCommand indicates an expected call of RunCommand.
func (mr *MockDbClientMockRecorder) RunCommand(ctx, runCommand any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, runCommand}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RunCommand", reflect.TypeOf((*MockDbClient)(nil).RunCommand), varargs...)
}

// SetRetry mocks base method.
func (m *MockDbClient) SetRetry(count int, timeout time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetRetry", count, timeout)
}

// SetRetry indicates an expected call of SetRetry.
func (mr *MockDbClientMockRecorder) SetRetry(count, timeout any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRetry", reflect.TypeOf((*MockDbClient)(nil).SetRetry), count, timeout)
}

// Watch mocks base method.
func (m *MockDbClient) Watch(ctx context.Context, pipeline any, opts ...options.Lister[options.ChangeStreamOptions]) (*mongo0.ChangeStream, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, pipeline}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Watch", varargs...)
	ret0, _ := ret[0].(*mongo0.ChangeStream)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Watch indicates an expected call of Watch.
func (mr *MockDbClientMockRecorder) Watch(ctx, pipeline any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, pipeline}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockDbClient)(nil).Watch), varargs...)
}

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

// WithTransaction indicates an expected call of WithTransaction.
func (mr *MockDbClientMockRecorder) WithTransaction(ctx, f any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTransaction", reflect.TypeOf((*MockDbClient)(nil).WithTransaction), ctx, f)
}

// MockSingleResultHelper is a mock of SingleResultHelper interface.
type MockSingleResultHelper struct {
	ctrl     *gomock.Controller
	recorder *MockSingleResultHelperMockRecorder
	isgomock struct{}
}

// MockSingleResultHelperMockRecorder is the mock recorder for MockSingleResultHelper.
type MockSingleResultHelperMockRecorder struct {
	mock *MockSingleResultHelper
}

// NewMockSingleResultHelper creates a new mock instance.
func NewMockSingleResultHelper(ctrl *gomock.Controller) *MockSingleResultHelper {
	mock := &MockSingleResultHelper{ctrl: ctrl}
	mock.recorder = &MockSingleResultHelperMockRecorder{mock}
	return mock
}

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

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

// Decode indicates an expected call of Decode.
func (mr *MockSingleResultHelperMockRecorder) Decode(v any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Decode", reflect.TypeOf((*MockSingleResultHelper)(nil).Decode), v)
}

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

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

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

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

// 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(ctx context.Context, results any) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "All", ctx, results)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

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

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

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

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

// 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(ctx context.Context) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close", ctx)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// 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(ctx context.Context) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next", ctx)
	ret0, _ := ret[0].(bool)
	return ret0
}

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

// 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(ctx context.Context) bool {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "TryNext", ctx)
	ret0, _ := ret[0].(bool)
	return ret0
}

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