beeorm

type Alter struct {
	SQL  string
	Safe bool
	Pool string
}

type Bind map[string]string

type CachedQuery struct{}

type ColumnSchemaDefinition struct {
	ColumnName string
	Definition string
}

type DB struct {
	// contains filtered or unexported fields
}

type DBClient interface {
	DBClientQuery
	Begin() (*sql.Tx, error)
}

type DBClientQuery interface {
	Prepare(query string) (*sql.Stmt, error)
	Exec(query string, args ...interface{}) (sql.Result, error)
	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
	QueryRow(query string, args ...interface{}) *sql.Row
	QueryRowContext(ctx context.Context, query string, args ...interface{}) *sql.Row
	Query(query string, args ...interface{}) (*sql.Rows, error)
	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
}

type DBClientTX interface {
	DBClientQuery
	Commit() error
	Rollback() error
}

type DuplicatedKeyError struct {
	Message string
	Index   string
}

type Engine interface {
	Clone() Engine
	EnableRequestCache()
	GetMysql(code ...string) *DB
	GetLocalCache(code ...string) LocalCache
	GetRedis(code ...string) RedisCache
	IsDirty(entity Entity) bool
	GetDirtyBind(entity Entity) (bind Bind, has bool)
	NewFlusher() Flusher
	Flush(entity ...Entity)
	FlushLazy(entity ...Entity)
	FlushWithCheck(entity ...Entity) error
	FlushWithFullCheck(entity ...Entity) error
	Delete(entity ...Entity)
	DeleteLazy(entity ...Entity)
	GetRegistry() ValidatedRegistry
	SearchWithCount(where *Where, pager *Pager, entities interface{}, references ...string) (totalRows int)
	Search(where *Where, pager *Pager, entities interface{}, references ...string)
	SearchIDsWithCount(where *Where, pager *Pager, entity Entity) (results []uint64, totalRows int)
	SearchIDs(where *Where, pager *Pager, entity Entity) []uint64
	SearchOne(where *Where, entity Entity, references ...string) (found bool)
	CachedSearchOne(entity Entity, indexName string, arguments ...interface{}) (found bool)
	CachedSearchOneWithReferences(entity Entity, indexName string, arguments []interface{}, references []string) (found bool)
	CachedSearch(entities interface{}, indexName string, pager *Pager, arguments ...interface{}) (totalRows int)
	CachedSearchIDs(entity Entity, indexName string, pager *Pager, arguments ...interface{}) (totalRows int, ids []uint64)
	CachedSearchCount(entity Entity, indexName string, arguments ...interface{}) int
	CachedSearchWithReferences(entities interface{}, indexName string, pager *Pager, arguments []interface{}, references []string) (totalRows int)
	ClearCacheByIDs(entity Entity, ids ...uint64)
	LoadByID(id uint64, entity Entity, references ...string) (found bool)
	Load(entity Entity, references ...string) (found bool)
	LoadByIDs(ids []uint64, entities interface{}, references ...string) (found bool)
	GetAlters() (alters []Alter)
	GetEventBroker() EventBroker
	RegisterQueryLogger(handler LogHandler, mysql, redis, local bool)
	EnableQueryDebug()
	EnableQueryDebugCustom(mysql, redis, local bool)
	SetPluginOption(plugin, key string, value interface{})
	GetPluginOption(plugin, key string) interface{}
	SetMetaData(key, value string)
	GetMetaData() Bind
	HasRedisLogger() (bool, []LogHandler)
}

type Entity interface {
	GetID() uint64

	IsLoaded() bool
	SetOnDuplicateKeyUpdate(bind Bind)
	SetField(field string, value interface{}) error
	Clone() Entity
	SetMetaData(key, value string)
	GetMetaData() Bind
	// contains filtered or unexported methods
}

type EntitySchema interface {
	GetTableName() string
	GetEntityName() string
	GetType() reflect.Type
	NewEntity() Entity
	DropTable(engine Engine)
	TruncateTable(engine Engine)
	UpdateSchema(engine Engine)
	UpdateSchemaAndTruncateTable(engine Engine)
	GetMysql(engine Engine) *DB
	GetMysqlPool() string
	GetLocalCache(engine Engine) (cache LocalCache, has bool)
	GetRedisCache(engine Engine) (cache RedisCache, has bool)
	GetReferences() []EntitySchemaReference
	GetColumns() []string
	GetUniqueIndexes() map[string][]string
	GetSchemaChanges(engine Engine) (has bool, alters []Alter)
	GetUsage(registry ValidatedRegistry) map[reflect.Type][]string
	GetTag(field, key, trueValue, defaultValue string) string
	GetPluginOption(plugin, key string) interface{}
	DisableCache(local, redis bool)
}

type EntitySchemaReference struct {
	ColumnName string
	FieldPath  []string
	EntityName string
}

type Enum interface {
	GetFields() []string
	GetDefault() string
	Has(value string) bool
	Index(value string) int
}

type Event interface {
	Ack()
	ID() string
	Stream() string
	Meta() Bind
	Unserialize(val interface{})
	// contains filtered or unexported methods
}

type EventBroker interface {
	Publish(stream string, body interface{}, meta Bind) (id string)
	Consumer(group string) EventsConsumer
	GetStreamsStatistics(stream ...string) []*RedisStreamStatistics
	GetStreamStatistics(stream string) *RedisStreamStatistics
	GetStreamGroupStatistics(stream, group string) *RedisStreamGroupStatistics
}

type EventConsumerHandler func(events []Event)

type EventEntityFlushed interface {
	Type() FlushType
	EntityName() string
	EntityID() uint64
	Before() Bind
	After() Bind
	MetaData() Bind
}

type EventEntityFlushing interface {
	EventEntityFlushed
	SetID(id uint64)
	SetType(t FlushType)
	SetBefore(before Bind)
	SetAfter(before Bind)
	SetMetaData(key, value string)
	SetField(field, bind string, value interface{}) error
}

type EventsConsumer interface {
	Consume(ctx context.Context, count int, handler EventConsumerHandler) bool
	ConsumeMany(ctx context.Context, nr, count int, handler EventConsumerHandler) bool
	Claim(from, to int)
	SetBlockTime(seconds int)
}

type ExecResult interface {
	LastInsertId() uint64
	RowsAffected() uint64
}

type FlushType int

type Flusher interface {
	FlusherCacheSetter
	Track(entity ...Entity) Flusher
	Flush()
	FlushWithCheck() error
	FlushWithFullCheck() error
	FlushLazy()
	Clear()
	Delete(entity ...Entity) Flusher
}

type FlusherCacheSetter interface {
	GetLocalCacheSetter(code ...string) LocalCacheSetter
	GetRedisCacheSetter(code ...string) RedisCacheSetter
	PublishToStream(stream string, body interface{}, meta Bind)
}

type IndexSchemaDefinition struct {
	Name   string
	Unique bool
	// contains filtered or unexported fields
}

type LazyFlushConsumer struct {
	// contains filtered or unexported fields
}

type LazyFlushQueryErrorResolver func(engine Engine, event EventEntityFlushed, queryError *mysql.MySQLError) error

type LocalCache interface {
	LocalCacheSetter
	GetPoolConfig() LocalCachePoolConfig
	GetSet(key string, ttl time.Duration, provider func() interface{}) interface{}
	Get(key string) (value interface{}, ok bool)
	MGet(keys ...string) []interface{}
	Clear()
	GetObjectsCount() int
}

type LocalCachePoolConfig interface {
	GetCode() string
	GetLimit() int
}

type LocalCacheSetter interface {
	Set(key string, value interface{})
	MSet(pairs ...interface{})
	Remove(keys ...string)
}

type Lock struct {
	// contains filtered or unexported fields
}

type Locker struct {
	// contains filtered or unexported fields
}

type LogHandler interface {
	Handle(engine Engine, log map[string]interface{})
}

type MockDBClient struct {
	OriginDB            DBClient
	TX                  DBClientTX
	PrepareMock         func(query string) (*sql.Stmt, error)
	ExecMock            func(query string, args ...interface{}) (sql.Result, error)
	ExecContextMock     func(context context.Context, query string, args ...interface{}) (sql.Result, error)
	QueryRowMock        func(query string, args ...interface{}) *sql.Row
	QueryRowContextMock func(ctx context.Context, query string, args ...interface{}) *sql.Row
	QueryMock           func(query string, args ...interface{}) (*sql.Rows, error)
	QueryContextMock    func(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
	BeginMock           func() (*sql.Tx, error)
	CommitMock          func() error
	RollbackMock        func() error
}

type MockLogHandler struct {
	Logs []map[string]interface{}
}

type MySQLPoolConfig interface {
	GetCode() string
	GetDatabase() string
	GetDataSourceURI() string
	GetVersion() int
	// contains filtered or unexported methods
}

type MySQLPoolOptions struct {
	ConnMaxLifetime    time.Duration
	MaxOpenConnections int
	MaxIdleConnections int
}

type ORM struct {
	// contains filtered or unexported fields
}

type Pager struct {
	// CurrentPage is the current page number.
	CurrentPage int

	// PageSize is the number of items per page.
	PageSize int
}

type PipeLineBool struct {
	// contains filtered or unexported fields
}

type PipeLineGet struct {
	// contains filtered or unexported fields
}

type PipeLineInt struct {
	// contains filtered or unexported fields
}

type PipeLineString struct {
	// contains filtered or unexported fields
}

type Plugin interface {
	GetCode() string
}

type PluginInterfaceEngineCreated interface {
	PluginInterfaceEngineCreated(engine Engine)
}

type PluginInterfaceEntityFlushed interface {
	PluginInterfaceEntityFlushed(engine Engine, event EventEntityFlushed, cacheFlusher FlusherCacheSetter)
}

type PluginInterfaceEntityFlushing interface {
	PluginInterfaceEntityFlushing(engine Engine, event EventEntityFlushing)
}

type PluginInterfaceEntitySearch interface {
	PluginInterfaceEntitySearch(engine Engine, schema EntitySchema, where *Where) *Where
}

type PluginInterfaceInitEntitySchema interface {
	InterfaceInitEntitySchema(schema SettableEntitySchema, registry *Registry) error
}

type PluginInterfaceInitRegistry interface {
	PluginInterfaceInitRegistry(registry *Registry)
}

type PluginInterfaceTableSQLSchemaDefinition interface {
	PluginInterfaceTableSQLSchemaDefinition(engine Engine, sqlSchema *TableSQLSchemaDefinition) error
}

type PreparedStmt interface {
	Exec(args ...any) ExecResult
	Query(args ...any) (rows Rows, close func())
	QueryRow(args []interface{}, toFill ...interface{}) (found bool)
	Close() error
}

type QueryLoggerSource int

type RedisCache interface {
	RedisCacheSetter
	GetSet(key string, expiration time.Duration, provider func() interface{}) interface{}
	PipeLine() *RedisPipeLine
	Info(section ...string) string
	GetPoolConfig() RedisPoolConfig
	Get(key string) (value string, has bool)
	Eval(script string, keys []string, args ...interface{}) interface{}
	EvalSha(sha1 string, keys []string, args ...interface{}) (res interface{}, exists bool)
	SetNX(key string, value interface{}, expiration time.Duration) bool
	ScriptExists(sha1 string) bool
	ScriptLoad(script string) string
	LPush(key string, values ...interface{}) int64
	RPush(key string, values ...interface{}) int64
	LLen(key string) int64
	Exists(keys ...string) int64
	Type(key string) string
	LRange(key string, start, stop int64) []string
	LSet(key string, index int64, value interface{})
	RPop(key string) (value string, found bool)
	LRem(key string, count int64, value interface{})
	Ltrim(key string, start, stop int64)
	HSetNx(key, field string, value interface{}) bool
	HDel(key string, fields ...string)
	HMGet(key string, fields ...string) map[string]interface{}
	HGetAll(key string) map[string]string
	HGet(key, field string) (value string, has bool)
	HLen(key string) int64
	HIncrBy(key, field string, incr int64) int64
	IncrBy(key string, incr int64) int64
	Incr(key string) int64
	IncrWithExpire(key string, expire time.Duration) int64
	Expire(key string, expiration time.Duration) bool
	ZAdd(key string, members ...redis.Z) int64
	ZRevRange(key string, start, stop int64) []string
	ZRevRangeWithScores(key string, start, stop int64) []redis.Z
	ZRangeWithScores(key string, start, stop int64) []redis.Z
	ZCard(key string) int64
	ZCount(key string, min, max string) int64
	ZScore(key, member string) float64
	MGet(keys ...string) []interface{}
	SAdd(key string, members ...interface{}) int64
	SCard(key string) int64
	SPop(key string) (string, bool)
	SPopN(key string, max int64) []string
	XTrim(stream string, maxLen int64) (deleted int64)
	XRange(stream, start, stop string, count int64) []redis.XMessage
	XRevRange(stream, start, stop string, count int64) []redis.XMessage
	XInfoStream(stream string) *redis.XInfoStream
	XInfoGroups(stream string) []redis.XInfoGroup
	XGroupCreate(stream, group, start string) (key string, exists bool)
	XGroupCreateMkStream(stream, group, start string) (key string, exists bool)
	XGroupDestroy(stream, group string) int64
	XRead(a *redis.XReadArgs) []redis.XStream
	XDel(stream string, ids ...string) int64
	XGroupDelConsumer(stream, group, consumer string) int64
	XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) (streams []redis.XStream)
	XPending(stream, group string) *redis.XPending
	XPendingExt(a *redis.XPendingExtArgs) []redis.XPendingExt
	XLen(stream string) int64
	XClaim(a *redis.XClaimArgs) []redis.XMessage
	XClaimJustID(a *redis.XClaimArgs) []string
	XAck(stream, group string, ids ...string) int64
	FlushAll()
	FlushDB()
	GetLocker() *Locker
	Process(ctx context.Context, cmd redis.Cmder) error
	HasNamespace() bool
	GetNamespace() string
	GetCode() string
	RemoveNamespacePrefix(key string) string
	AddNamespacePrefix(key string) string
}

type RedisCacheSetter interface {
	Set(key string, value interface{}, expiration time.Duration)
	MSet(pairs ...interface{})
	Del(keys ...string)

	HSet(key string, values ...interface{})
	// contains filtered or unexported methods
}

type RedisPipeLine struct {
	// contains filtered or unexported fields
}

type RedisPoolConfig interface {
	GetCode() string
	GetDatabase() int
	GetAddress() string
	GetNamespace() string
	HasNamespace() bool
	// contains filtered or unexported methods
}

type RedisStreamConsumerStatistics struct {
	Name    string
	Pending uint64
}

type RedisStreamGroupStatistics struct {
	Group                 string
	Lag                   int64
	Pending               uint64
	LastDeliveredID       string
	LastDeliveredDuration time.Duration
	LowerID               string
	LowerDuration         time.Duration
	Consumers             []*RedisStreamConsumerStatistics
}

type RedisStreamStatistics struct {
	Stream             string
	RedisPool          string
	Len                uint64
	OldestEventSeconds int
	Groups             []*RedisStreamGroupStatistics
}

type Registry struct {
	// contains filtered or unexported fields
}

type Rows interface {
	Next() bool
	Scan(dest ...interface{})
	Columns() []string
}

type SQLRow interface {
	Scan(dest ...interface{}) error
}

type SQLRows interface {
	Next() bool
	Err() error
	Close() error
	Scan(dest ...interface{}) error
	Columns() ([]string, error)
}

type SettableEntitySchema interface {
	EntitySchema
	SetPluginOption(plugin, key string, value interface{})
}

type StreamGarbageCollectorConsumer struct {
	// contains filtered or unexported fields
}

type TableSQLSchemaDefinition struct {
	EntitySchema   EntitySchema
	EntityColumns  []*ColumnSchemaDefinition
	EntityIndexes  []*IndexSchemaDefinition
	DBTableColumns []*ColumnSchemaDefinition
	DBIndexes      []*IndexSchemaDefinition
	DBCreateSchema string
	DBEncoding     string
	PreAlters      []Alter
	PostAlters     []Alter
	// contains filtered or unexported fields
}

type ValidatedRegistry interface {
	CreateEngine() Engine
	GetEntitySchema(entityName string) EntitySchema
	GetEntitySchemaForEntity(entity Entity) EntitySchema
	GetEntitySchemaForCachePrefix(cachePrefix string) EntitySchema
	GetSourceRegistry() *Registry
	GetEnum(code string) Enum
	GetRedisStreams() map[string]map[string][]string
	GetMySQLPools() map[string]MySQLPoolConfig
	GetLocalCachePools() map[string]LocalCachePoolConfig
	GetRedisPools() map[string]RedisPoolConfig
	GetEntities() map[string]reflect.Type
	GetPlugins() []string
	GetPlugin(code string) Plugin
}

type Where struct {
	// contains filtered or unexported fields
}