// Code generated by mockery v2.53.5. DO NOT EDIT.

package mocks

import (
	dbmodel "github.com/chroma-core/chroma/go/pkg/sysdb/metastore/db/dbmodel"
	mock "github.com/stretchr/testify/mock"

	time "time"
)

// ICollectionDb is an autogenerated mock type for the ICollectionDb type
type ICollectionDb struct {
	mock.Mock
}

// BatchGetCollectionSoftDeleteStatus provides a mock function with given fields: collectionIDs
func (_m *ICollectionDb) BatchGetCollectionSoftDeleteStatus(collectionIDs []string) (map[string]bool, error) {
	ret := _m.Called(collectionIDs)

	if len(ret) == 0 {
		panic("no return value specified for BatchGetCollectionSoftDeleteStatus")
	}

	var r0 map[string]bool
	var r1 error
	if rf, ok := ret.Get(0).(func([]string) (map[string]bool, error)); ok {
		return rf(collectionIDs)
	}
	if rf, ok := ret.Get(0).(func([]string) map[string]bool); ok {
		r0 = rf(collectionIDs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]bool)
		}
	}

	if rf, ok := ret.Get(1).(func([]string) error); ok {
		r1 = rf(collectionIDs)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// BatchGetCollectionVersionFilePaths provides a mock function with given fields: collectionIDs
func (_m *ICollectionDb) BatchGetCollectionVersionFilePaths(collectionIDs []string) (map[string]string, error) {
	ret := _m.Called(collectionIDs)

	if len(ret) == 0 {
		panic("no return value specified for BatchGetCollectionVersionFilePaths")
	}

	var r0 map[string]string
	var r1 error
	if rf, ok := ret.Get(0).(func([]string) (map[string]string, error)); ok {
		return rf(collectionIDs)
	}
	if rf, ok := ret.Get(0).(func([]string) map[string]string); ok {
		r0 = rf(collectionIDs)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(map[string]string)
		}
	}

	if rf, ok := ret.Get(1).(func([]string) error); ok {
		r1 = rf(collectionIDs)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// CountCollections provides a mock function with given fields: tenantID, databaseName
func (_m *ICollectionDb) CountCollections(tenantID string, databaseName *string) (uint64, error) {
	ret := _m.Called(tenantID, databaseName)

	if len(ret) == 0 {
		panic("no return value specified for CountCollections")
	}

	var r0 uint64
	var r1 error
	if rf, ok := ret.Get(0).(func(string, *string) (uint64, error)); ok {
		return rf(tenantID, databaseName)
	}
	if rf, ok := ret.Get(0).(func(string, *string) uint64); ok {
		r0 = rf(tenantID, databaseName)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	if rf, ok := ret.Get(1).(func(string, *string) error); ok {
		r1 = rf(tenantID, databaseName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// DeleteAll provides a mock function with no fields
func (_m *ICollectionDb) DeleteAll() error {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for DeleteAll")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func() error); ok {
		r0 = rf()
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DeleteCollectionByID provides a mock function with given fields: collectionID
func (_m *ICollectionDb) DeleteCollectionByID(collectionID string) (int, error) {
	ret := _m.Called(collectionID)

	if len(ret) == 0 {
		panic("no return value specified for DeleteCollectionByID")
	}

	var r0 int
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (int, error)); ok {
		return rf(collectionID)
	}
	if rf, ok := ret.Get(0).(func(string) int); ok {
		r0 = rf(collectionID)
	} else {
		r0 = ret.Get(0).(int)
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(collectionID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCollectionByResourceName provides a mock function with given fields: tenantResourceName, databaseName, collectionName
func (_m *ICollectionDb) GetCollectionByResourceName(tenantResourceName string, databaseName string, collectionName string) (*dbmodel.CollectionAndMetadata, error) {
	ret := _m.Called(tenantResourceName, databaseName, collectionName)

	if len(ret) == 0 {
		panic("no return value specified for GetCollectionByResourceName")
	}

	var r0 *dbmodel.CollectionAndMetadata
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, string) (*dbmodel.CollectionAndMetadata, error)); ok {
		return rf(tenantResourceName, databaseName, collectionName)
	}
	if rf, ok := ret.Get(0).(func(string, string, string) *dbmodel.CollectionAndMetadata); ok {
		r0 = rf(tenantResourceName, databaseName, collectionName)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dbmodel.CollectionAndMetadata)
		}
	}

	if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
		r1 = rf(tenantResourceName, databaseName, collectionName)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCollectionEntries provides a mock function with given fields: id, name, tenantID, databaseName, limit, offset
func (_m *ICollectionDb) GetCollectionEntries(id *string, name *string, tenantID string, databaseName string, limit *int32, offset *int32) ([]*dbmodel.CollectionAndMetadata, error) {
	ret := _m.Called(id, name, tenantID, databaseName, limit, offset)

	if len(ret) == 0 {
		panic("no return value specified for GetCollectionEntries")
	}

	var r0 []*dbmodel.CollectionAndMetadata
	var r1 error
	if rf, ok := ret.Get(0).(func(*string, *string, string, string, *int32, *int32) ([]*dbmodel.CollectionAndMetadata, error)); ok {
		return rf(id, name, tenantID, databaseName, limit, offset)
	}
	if rf, ok := ret.Get(0).(func(*string, *string, string, string, *int32, *int32) []*dbmodel.CollectionAndMetadata); ok {
		r0 = rf(id, name, tenantID, databaseName, limit, offset)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*dbmodel.CollectionAndMetadata)
		}
	}

	if rf, ok := ret.Get(1).(func(*string, *string, string, string, *int32, *int32) error); ok {
		r1 = rf(id, name, tenantID, databaseName, limit, offset)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCollectionSize provides a mock function with given fields: collectionID
func (_m *ICollectionDb) GetCollectionSize(collectionID string) (uint64, error) {
	ret := _m.Called(collectionID)

	if len(ret) == 0 {
		panic("no return value specified for GetCollectionSize")
	}

	var r0 uint64
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (uint64, error)); ok {
		return rf(collectionID)
	}
	if rf, ok := ret.Get(0).(func(string) uint64); ok {
		r0 = rf(collectionID)
	} else {
		r0 = ret.Get(0).(uint64)
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(collectionID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCollectionWithoutMetadata provides a mock function with given fields: collectionID, databaseName, softDeletedFlag
func (_m *ICollectionDb) GetCollectionWithoutMetadata(collectionID *string, databaseName *string, softDeletedFlag *bool) (*dbmodel.Collection, error) {
	ret := _m.Called(collectionID, databaseName, softDeletedFlag)

	if len(ret) == 0 {
		panic("no return value specified for GetCollectionWithoutMetadata")
	}

	var r0 *dbmodel.Collection
	var r1 error
	if rf, ok := ret.Get(0).(func(*string, *string, *bool) (*dbmodel.Collection, error)); ok {
		return rf(collectionID, databaseName, softDeletedFlag)
	}
	if rf, ok := ret.Get(0).(func(*string, *string, *bool) *dbmodel.Collection); ok {
		r0 = rf(collectionID, databaseName, softDeletedFlag)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*dbmodel.Collection)
		}
	}

	if rf, ok := ret.Get(1).(func(*string, *string, *bool) error); ok {
		r1 = rf(collectionID, databaseName, softDeletedFlag)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetCollections provides a mock function with given fields: collectionIDs, collectionName, tenantID, databaseName, limit, offset, includeSoftDeleted
func (_m *ICollectionDb) GetCollections(collectionIDs []string, collectionName *string, tenantID string, databaseName string, limit *int32, offset *int32, includeSoftDeleted bool) ([]*dbmodel.CollectionAndMetadata, error) {
	ret := _m.Called(collectionIDs, collectionName, tenantID, databaseName, limit, offset, includeSoftDeleted)

	if len(ret) == 0 {
		panic("no return value specified for GetCollections")
	}

	var r0 []*dbmodel.CollectionAndMetadata
	var r1 error
	if rf, ok := ret.Get(0).(func([]string, *string, string, string, *int32, *int32, bool) ([]*dbmodel.CollectionAndMetadata, error)); ok {
		return rf(collectionIDs, collectionName, tenantID, databaseName, limit, offset, includeSoftDeleted)
	}
	if rf, ok := ret.Get(0).(func([]string, *string, string, string, *int32, *int32, bool) []*dbmodel.CollectionAndMetadata); ok {
		r0 = rf(collectionIDs, collectionName, tenantID, databaseName, limit, offset, includeSoftDeleted)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*dbmodel.CollectionAndMetadata)
		}
	}

	if rf, ok := ret.Get(1).(func([]string, *string, string, string, *int32, *int32, bool) error); ok {
		r1 = rf(collectionIDs, collectionName, tenantID, databaseName, limit, offset, includeSoftDeleted)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// GetSoftDeletedCollections provides a mock function with given fields: collectionID, tenantID, databaseName, limit
func (_m *ICollectionDb) GetSoftDeletedCollections(collectionID *string, tenantID string, databaseName string, limit int32) ([]*dbmodel.CollectionAndMetadata, error) {
	ret := _m.Called(collectionID, tenantID, databaseName, limit)

	if len(ret) == 0 {
		panic("no return value specified for GetSoftDeletedCollections")
	}

	var r0 []*dbmodel.CollectionAndMetadata
	var r1 error
	if rf, ok := ret.Get(0).(func(*string, string, string, int32) ([]*dbmodel.CollectionAndMetadata, error)); ok {
		return rf(collectionID, tenantID, databaseName, limit)
	}
	if rf, ok := ret.Get(0).(func(*string, string, string, int32) []*dbmodel.CollectionAndMetadata); ok {
		r0 = rf(collectionID, tenantID, databaseName, limit)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*dbmodel.CollectionAndMetadata)
		}
	}

	if rf, ok := ret.Get(1).(func(*string, string, string, int32) error); ok {
		r1 = rf(collectionID, tenantID, databaseName, limit)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// IncrementCompactionFailureCount provides a mock function with given fields: collectionID
func (_m *ICollectionDb) IncrementCompactionFailureCount(collectionID string) error {
	ret := _m.Called(collectionID)

	if len(ret) == 0 {
		panic("no return value specified for IncrementCompactionFailureCount")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(string) error); ok {
		r0 = rf(collectionID)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// Insert provides a mock function with given fields: in
func (_m *ICollectionDb) Insert(in *dbmodel.Collection) error {
	ret := _m.Called(in)

	if len(ret) == 0 {
		panic("no return value specified for Insert")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(*dbmodel.Collection) error); ok {
		r0 = rf(in)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// InsertOnConflictDoNothing provides a mock function with given fields: in
func (_m *ICollectionDb) InsertOnConflictDoNothing(in *dbmodel.Collection) (bool, error) {
	ret := _m.Called(in)

	if len(ret) == 0 {
		panic("no return value specified for InsertOnConflictDoNothing")
	}

	var r0 bool
	var r1 error
	if rf, ok := ret.Get(0).(func(*dbmodel.Collection) (bool, error)); ok {
		return rf(in)
	}
	if rf, ok := ret.Get(0).(func(*dbmodel.Collection) bool); ok {
		r0 = rf(in)
	} else {
		r0 = ret.Get(0).(bool)
	}

	if rf, ok := ret.Get(1).(func(*dbmodel.Collection) error); ok {
		r1 = rf(in)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// ListCollectionsToGc provides a mock function with given fields: cutoffTimeSecs, limit, tenantID, minVersionsIfAlive
func (_m *ICollectionDb) ListCollectionsToGc(cutoffTimeSecs *uint64, limit *uint64, tenantID *string, minVersionsIfAlive *uint64) ([]*dbmodel.CollectionToGc, error) {
	ret := _m.Called(cutoffTimeSecs, limit, tenantID, minVersionsIfAlive)

	if len(ret) == 0 {
		panic("no return value specified for ListCollectionsToGc")
	}

	var r0 []*dbmodel.CollectionToGc
	var r1 error
	if rf, ok := ret.Get(0).(func(*uint64, *uint64, *string, *uint64) ([]*dbmodel.CollectionToGc, error)); ok {
		return rf(cutoffTimeSecs, limit, tenantID, minVersionsIfAlive)
	}
	if rf, ok := ret.Get(0).(func(*uint64, *uint64, *string, *uint64) []*dbmodel.CollectionToGc); ok {
		r0 = rf(cutoffTimeSecs, limit, tenantID, minVersionsIfAlive)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]*dbmodel.CollectionToGc)
		}
	}

	if rf, ok := ret.Get(1).(func(*uint64, *uint64, *string, *uint64) error); ok {
		r1 = rf(cutoffTimeSecs, limit, tenantID, minVersionsIfAlive)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// LockCollection provides a mock function with given fields: collectionID
func (_m *ICollectionDb) LockCollection(collectionID string) (*bool, error) {
	ret := _m.Called(collectionID)

	if len(ret) == 0 {
		panic("no return value specified for LockCollection")
	}

	var r0 *bool
	var r1 error
	if rf, ok := ret.Get(0).(func(string) (*bool, error)); ok {
		return rf(collectionID)
	}
	if rf, ok := ret.Get(0).(func(string) *bool); ok {
		r0 = rf(collectionID)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*bool)
		}
	}

	if rf, ok := ret.Get(1).(func(string) error); ok {
		r1 = rf(collectionID)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// Update provides a mock function with given fields: in
func (_m *ICollectionDb) Update(in *dbmodel.Collection) error {
	ret := _m.Called(in)

	if len(ret) == 0 {
		panic("no return value specified for Update")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(*dbmodel.Collection) error); ok {
		r0 = rf(in)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// UpdateCollectionLineageFilePath provides a mock function with given fields: collectionID, currentLineageFilePath, newLineageFilePath
func (_m *ICollectionDb) UpdateCollectionLineageFilePath(collectionID string, currentLineageFilePath *string, newLineageFilePath string) error {
	ret := _m.Called(collectionID, currentLineageFilePath, newLineageFilePath)

	if len(ret) == 0 {
		panic("no return value specified for UpdateCollectionLineageFilePath")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(string, *string, string) error); ok {
		r0 = rf(collectionID, currentLineageFilePath, newLineageFilePath)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// UpdateLogPositionAndVersionInfo provides a mock function with given fields: collectionID, logPosition, currentCollectionVersion, currentVersionFilePath, newCollectionVersion, newVersionFilePath, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, numVersions, schemaStr
func (_m *ICollectionDb) UpdateLogPositionAndVersionInfo(collectionID string, logPosition int64, currentCollectionVersion int32, currentVersionFilePath string, newCollectionVersion int32, newVersionFilePath string, totalRecordsPostCompaction uint64, sizeBytesPostCompaction uint64, lastCompactionTimeSecs uint64, numVersions uint64, schemaStr *string) (int64, error) {
	ret := _m.Called(collectionID, logPosition, currentCollectionVersion, currentVersionFilePath, newCollectionVersion, newVersionFilePath, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, numVersions, schemaStr)

	if len(ret) == 0 {
		panic("no return value specified for UpdateLogPositionAndVersionInfo")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(string, int64, int32, string, int32, string, uint64, uint64, uint64, uint64, *string) (int64, error)); ok {
		return rf(collectionID, logPosition, currentCollectionVersion, currentVersionFilePath, newCollectionVersion, newVersionFilePath, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, numVersions, schemaStr)
	}
	if rf, ok := ret.Get(0).(func(string, int64, int32, string, int32, string, uint64, uint64, uint64, uint64, *string) int64); ok {
		r0 = rf(collectionID, logPosition, currentCollectionVersion, currentVersionFilePath, newCollectionVersion, newVersionFilePath, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, numVersions, schemaStr)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(string, int64, int32, string, int32, string, uint64, uint64, uint64, uint64, *string) error); ok {
		r1 = rf(collectionID, logPosition, currentCollectionVersion, currentVersionFilePath, newCollectionVersion, newVersionFilePath, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, numVersions, schemaStr)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateLogPositionVersionTotalRecordsAndLogicalSize provides a mock function with given fields: collectionID, logPosition, currentCollectionVersion, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, tenant, schemaStr
func (_m *ICollectionDb) UpdateLogPositionVersionTotalRecordsAndLogicalSize(collectionID string, logPosition int64, currentCollectionVersion int32, totalRecordsPostCompaction uint64, sizeBytesPostCompaction uint64, lastCompactionTimeSecs uint64, tenant string, schemaStr *string) (int32, error) {
	ret := _m.Called(collectionID, logPosition, currentCollectionVersion, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, tenant, schemaStr)

	if len(ret) == 0 {
		panic("no return value specified for UpdateLogPositionVersionTotalRecordsAndLogicalSize")
	}

	var r0 int32
	var r1 error
	if rf, ok := ret.Get(0).(func(string, int64, int32, uint64, uint64, uint64, string, *string) (int32, error)); ok {
		return rf(collectionID, logPosition, currentCollectionVersion, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, tenant, schemaStr)
	}
	if rf, ok := ret.Get(0).(func(string, int64, int32, uint64, uint64, uint64, string, *string) int32); ok {
		r0 = rf(collectionID, logPosition, currentCollectionVersion, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, tenant, schemaStr)
	} else {
		r0 = ret.Get(0).(int32)
	}

	if rf, ok := ret.Get(1).(func(string, int64, int32, uint64, uint64, uint64, string, *string) error); ok {
		r1 = rf(collectionID, logPosition, currentCollectionVersion, totalRecordsPostCompaction, sizeBytesPostCompaction, lastCompactionTimeSecs, tenant, schemaStr)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// UpdateVersionRelatedFields provides a mock function with given fields: collectionID, existingVersionFileName, newVersionFileName, oldestVersionTs, numActiveVersions
func (_m *ICollectionDb) UpdateVersionRelatedFields(collectionID string, existingVersionFileName string, newVersionFileName string, oldestVersionTs *time.Time, numActiveVersions *int) (int64, error) {
	ret := _m.Called(collectionID, existingVersionFileName, newVersionFileName, oldestVersionTs, numActiveVersions)

	if len(ret) == 0 {
		panic("no return value specified for UpdateVersionRelatedFields")
	}

	var r0 int64
	var r1 error
	if rf, ok := ret.Get(0).(func(string, string, string, *time.Time, *int) (int64, error)); ok {
		return rf(collectionID, existingVersionFileName, newVersionFileName, oldestVersionTs, numActiveVersions)
	}
	if rf, ok := ret.Get(0).(func(string, string, string, *time.Time, *int) int64); ok {
		r0 = rf(collectionID, existingVersionFileName, newVersionFileName, oldestVersionTs, numActiveVersions)
	} else {
		r0 = ret.Get(0).(int64)
	}

	if rf, ok := ret.Get(1).(func(string, string, string, *time.Time, *int) error); ok {
		r1 = rf(collectionID, existingVersionFileName, newVersionFileName, oldestVersionTs, numActiveVersions)
	} else {
		r1 = ret.Error(1)
	}

	return r0, r1
}

// NewICollectionDb creates a new instance of ICollectionDb. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewICollectionDb(t interface {
	mock.TestingT
	Cleanup(func())
}) *ICollectionDb {
	mock := &ICollectionDb{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
