dal

type ICommitDo interface {
	gen.SubQuery
	Debug() ICommitDo
	WithContext(ctx context.Context) ICommitDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ICommitDo
	WriteDB() ICommitDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ICommitDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ICommitDo
	Not(conds ...gen.Condition) ICommitDo
	Or(conds ...gen.Condition) ICommitDo
	Select(conds ...field.Expr) ICommitDo
	Where(conds ...gen.Condition) ICommitDo
	Order(conds ...field.Expr) ICommitDo
	Distinct(cols ...field.Expr) ICommitDo
	Omit(cols ...field.Expr) ICommitDo
	Join(table schema.Tabler, on ...field.Expr) ICommitDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ICommitDo
	RightJoin(table schema.Tabler, on ...field.Expr) ICommitDo
	Group(cols ...field.Expr) ICommitDo
	Having(conds ...gen.Condition) ICommitDo
	Limit(limit int) ICommitDo
	Offset(offset int) ICommitDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ICommitDo
	Unscoped() ICommitDo
	Create(values ...*model.Commit) error
	CreateInBatches(values []*model.Commit, batchSize int) error
	Save(values ...*model.Commit) error
	First() (*model.Commit, error)
	Take() (*model.Commit, error)
	Last() (*model.Commit, error)
	Find() ([]*model.Commit, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Commit, err error)
	FindInBatches(result *[]*model.Commit, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Commit) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) ICommitDo
	Assign(attrs ...field.AssignExpr) ICommitDo
	Joins(fields ...field.RelationField) ICommitDo
	Preload(fields ...field.RelationField) ICommitDo
	FirstOrInit() (*model.Commit, error)
	FirstOrCreate() (*model.Commit, error)
	FindByPage(offset int, limit int) (result []*model.Commit, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) ICommitDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IDockerRepoDo interface {
	gen.SubQuery
	Debug() IDockerRepoDo
	WithContext(ctx context.Context) IDockerRepoDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IDockerRepoDo
	WriteDB() IDockerRepoDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IDockerRepoDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IDockerRepoDo
	Not(conds ...gen.Condition) IDockerRepoDo
	Or(conds ...gen.Condition) IDockerRepoDo
	Select(conds ...field.Expr) IDockerRepoDo
	Where(conds ...gen.Condition) IDockerRepoDo
	Order(conds ...field.Expr) IDockerRepoDo
	Distinct(cols ...field.Expr) IDockerRepoDo
	Omit(cols ...field.Expr) IDockerRepoDo
	Join(table schema.Tabler, on ...field.Expr) IDockerRepoDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IDockerRepoDo
	RightJoin(table schema.Tabler, on ...field.Expr) IDockerRepoDo
	Group(cols ...field.Expr) IDockerRepoDo
	Having(conds ...gen.Condition) IDockerRepoDo
	Limit(limit int) IDockerRepoDo
	Offset(offset int) IDockerRepoDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IDockerRepoDo
	Unscoped() IDockerRepoDo
	Create(values ...*model.DockerRepo) error
	CreateInBatches(values []*model.DockerRepo, batchSize int) error
	Save(values ...*model.DockerRepo) error
	First() (*model.DockerRepo, error)
	Take() (*model.DockerRepo, error)
	Last() (*model.DockerRepo, error)
	Find() ([]*model.DockerRepo, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DockerRepo, err error)
	FindInBatches(result *[]*model.DockerRepo, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.DockerRepo) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IDockerRepoDo
	Assign(attrs ...field.AssignExpr) IDockerRepoDo
	Joins(fields ...field.RelationField) IDockerRepoDo
	Preload(fields ...field.RelationField) IDockerRepoDo
	FirstOrInit() (*model.DockerRepo, error)
	FirstOrCreate() (*model.DockerRepo, error)
	FindByPage(offset int, limit int) (result []*model.DockerRepo, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IDockerRepoDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IFileBlobDo interface {
	gen.SubQuery
	Debug() IFileBlobDo
	WithContext(ctx context.Context) IFileBlobDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IFileBlobDo
	WriteDB() IFileBlobDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IFileBlobDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IFileBlobDo
	Not(conds ...gen.Condition) IFileBlobDo
	Or(conds ...gen.Condition) IFileBlobDo
	Select(conds ...field.Expr) IFileBlobDo
	Where(conds ...gen.Condition) IFileBlobDo
	Order(conds ...field.Expr) IFileBlobDo
	Distinct(cols ...field.Expr) IFileBlobDo
	Omit(cols ...field.Expr) IFileBlobDo
	Join(table schema.Tabler, on ...field.Expr) IFileBlobDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IFileBlobDo
	RightJoin(table schema.Tabler, on ...field.Expr) IFileBlobDo
	Group(cols ...field.Expr) IFileBlobDo
	Having(conds ...gen.Condition) IFileBlobDo
	Limit(limit int) IFileBlobDo
	Offset(offset int) IFileBlobDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IFileBlobDo
	Unscoped() IFileBlobDo
	Create(values ...*model.FileBlob) error
	CreateInBatches(values []*model.FileBlob, batchSize int) error
	Save(values ...*model.FileBlob) error
	First() (*model.FileBlob, error)
	Take() (*model.FileBlob, error)
	Last() (*model.FileBlob, error)
	Find() ([]*model.FileBlob, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FileBlob, err error)
	FindInBatches(result *[]*model.FileBlob, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.FileBlob) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IFileBlobDo
	Assign(attrs ...field.AssignExpr) IFileBlobDo
	Joins(fields ...field.RelationField) IFileBlobDo
	Preload(fields ...field.RelationField) IFileBlobDo
	FirstOrInit() (*model.FileBlob, error)
	FirstOrCreate() (*model.FileBlob, error)
	FindByPage(offset int, limit int) (result []*model.FileBlob, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IFileBlobDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IFileManifestDo interface {
	gen.SubQuery
	Debug() IFileManifestDo
	WithContext(ctx context.Context) IFileManifestDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IFileManifestDo
	WriteDB() IFileManifestDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IFileManifestDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IFileManifestDo
	Not(conds ...gen.Condition) IFileManifestDo
	Or(conds ...gen.Condition) IFileManifestDo
	Select(conds ...field.Expr) IFileManifestDo
	Where(conds ...gen.Condition) IFileManifestDo
	Order(conds ...field.Expr) IFileManifestDo
	Distinct(cols ...field.Expr) IFileManifestDo
	Omit(cols ...field.Expr) IFileManifestDo
	Join(table schema.Tabler, on ...field.Expr) IFileManifestDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IFileManifestDo
	RightJoin(table schema.Tabler, on ...field.Expr) IFileManifestDo
	Group(cols ...field.Expr) IFileManifestDo
	Having(conds ...gen.Condition) IFileManifestDo
	Limit(limit int) IFileManifestDo
	Offset(offset int) IFileManifestDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IFileManifestDo
	Unscoped() IFileManifestDo
	Create(values ...*model.FileManifest) error
	CreateInBatches(values []*model.FileManifest, batchSize int) error
	Save(values ...*model.FileManifest) error
	First() (*model.FileManifest, error)
	Take() (*model.FileManifest, error)
	Last() (*model.FileManifest, error)
	Find() ([]*model.FileManifest, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FileManifest, err error)
	FindInBatches(result *[]*model.FileManifest, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.FileManifest) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IFileManifestDo
	Assign(attrs ...field.AssignExpr) IFileManifestDo
	Joins(fields ...field.RelationField) IFileManifestDo
	Preload(fields ...field.RelationField) IFileManifestDo
	FirstOrInit() (*model.FileManifest, error)
	FirstOrCreate() (*model.FileManifest, error)
	FindByPage(offset int, limit int) (result []*model.FileManifest, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IFileManifestDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IPluginDo interface {
	gen.SubQuery
	Debug() IPluginDo
	WithContext(ctx context.Context) IPluginDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IPluginDo
	WriteDB() IPluginDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IPluginDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IPluginDo
	Not(conds ...gen.Condition) IPluginDo
	Or(conds ...gen.Condition) IPluginDo
	Select(conds ...field.Expr) IPluginDo
	Where(conds ...gen.Condition) IPluginDo
	Order(conds ...field.Expr) IPluginDo
	Distinct(cols ...field.Expr) IPluginDo
	Omit(cols ...field.Expr) IPluginDo
	Join(table schema.Tabler, on ...field.Expr) IPluginDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IPluginDo
	RightJoin(table schema.Tabler, on ...field.Expr) IPluginDo
	Group(cols ...field.Expr) IPluginDo
	Having(conds ...gen.Condition) IPluginDo
	Limit(limit int) IPluginDo
	Offset(offset int) IPluginDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IPluginDo
	Unscoped() IPluginDo
	Create(values ...*model.Plugin) error
	CreateInBatches(values []*model.Plugin, batchSize int) error
	Save(values ...*model.Plugin) error
	First() (*model.Plugin, error)
	Take() (*model.Plugin, error)
	Last() (*model.Plugin, error)
	Find() ([]*model.Plugin, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Plugin, err error)
	FindInBatches(result *[]*model.Plugin, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Plugin) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IPluginDo
	Assign(attrs ...field.AssignExpr) IPluginDo
	Joins(fields ...field.RelationField) IPluginDo
	Preload(fields ...field.RelationField) IPluginDo
	FirstOrInit() (*model.Plugin, error)
	FirstOrCreate() (*model.Plugin, error)
	FindByPage(offset int, limit int) (result []*model.Plugin, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IPluginDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IRepositoryDo interface {
	gen.SubQuery
	Debug() IRepositoryDo
	WithContext(ctx context.Context) IRepositoryDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IRepositoryDo
	WriteDB() IRepositoryDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IRepositoryDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IRepositoryDo
	Not(conds ...gen.Condition) IRepositoryDo
	Or(conds ...gen.Condition) IRepositoryDo
	Select(conds ...field.Expr) IRepositoryDo
	Where(conds ...gen.Condition) IRepositoryDo
	Order(conds ...field.Expr) IRepositoryDo
	Distinct(cols ...field.Expr) IRepositoryDo
	Omit(cols ...field.Expr) IRepositoryDo
	Join(table schema.Tabler, on ...field.Expr) IRepositoryDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IRepositoryDo
	RightJoin(table schema.Tabler, on ...field.Expr) IRepositoryDo
	Group(cols ...field.Expr) IRepositoryDo
	Having(conds ...gen.Condition) IRepositoryDo
	Limit(limit int) IRepositoryDo
	Offset(offset int) IRepositoryDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IRepositoryDo
	Unscoped() IRepositoryDo
	Create(values ...*model.Repository) error
	CreateInBatches(values []*model.Repository, batchSize int) error
	Save(values ...*model.Repository) error
	First() (*model.Repository, error)
	Take() (*model.Repository, error)
	Last() (*model.Repository, error)
	Find() ([]*model.Repository, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Repository, err error)
	FindInBatches(result *[]*model.Repository, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Repository) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IRepositoryDo
	Assign(attrs ...field.AssignExpr) IRepositoryDo
	Joins(fields ...field.RelationField) IRepositoryDo
	Preload(fields ...field.RelationField) IRepositoryDo
	FirstOrInit() (*model.Repository, error)
	FirstOrCreate() (*model.Repository, error)
	FindByPage(offset int, limit int) (result []*model.Repository, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IRepositoryDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ITagDo interface {
	gen.SubQuery
	Debug() ITagDo
	WithContext(ctx context.Context) ITagDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ITagDo
	WriteDB() ITagDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ITagDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ITagDo
	Not(conds ...gen.Condition) ITagDo
	Or(conds ...gen.Condition) ITagDo
	Select(conds ...field.Expr) ITagDo
	Where(conds ...gen.Condition) ITagDo
	Order(conds ...field.Expr) ITagDo
	Distinct(cols ...field.Expr) ITagDo
	Omit(cols ...field.Expr) ITagDo
	Join(table schema.Tabler, on ...field.Expr) ITagDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ITagDo
	RightJoin(table schema.Tabler, on ...field.Expr) ITagDo
	Group(cols ...field.Expr) ITagDo
	Having(conds ...gen.Condition) ITagDo
	Limit(limit int) ITagDo
	Offset(offset int) ITagDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ITagDo
	Unscoped() ITagDo
	Create(values ...*model.Tag) error
	CreateInBatches(values []*model.Tag, batchSize int) error
	Save(values ...*model.Tag) error
	First() (*model.Tag, error)
	Take() (*model.Tag, error)
	Last() (*model.Tag, error)
	Find() ([]*model.Tag, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Tag, err error)
	FindInBatches(result *[]*model.Tag, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Tag) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) ITagDo
	Assign(attrs ...field.AssignExpr) ITagDo
	Joins(fields ...field.RelationField) ITagDo
	Preload(fields ...field.RelationField) ITagDo
	FirstOrInit() (*model.Tag, error)
	FirstOrCreate() (*model.Tag, error)
	FindByPage(offset int, limit int) (result []*model.Tag, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) ITagDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ITokenDo interface {
	gen.SubQuery
	Debug() ITokenDo
	WithContext(ctx context.Context) ITokenDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ITokenDo
	WriteDB() ITokenDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ITokenDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ITokenDo
	Not(conds ...gen.Condition) ITokenDo
	Or(conds ...gen.Condition) ITokenDo
	Select(conds ...field.Expr) ITokenDo
	Where(conds ...gen.Condition) ITokenDo
	Order(conds ...field.Expr) ITokenDo
	Distinct(cols ...field.Expr) ITokenDo
	Omit(cols ...field.Expr) ITokenDo
	Join(table schema.Tabler, on ...field.Expr) ITokenDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ITokenDo
	RightJoin(table schema.Tabler, on ...field.Expr) ITokenDo
	Group(cols ...field.Expr) ITokenDo
	Having(conds ...gen.Condition) ITokenDo
	Limit(limit int) ITokenDo
	Offset(offset int) ITokenDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ITokenDo
	Unscoped() ITokenDo
	Create(values ...*model.Token) error
	CreateInBatches(values []*model.Token, batchSize int) error
	Save(values ...*model.Token) error
	First() (*model.Token, error)
	Take() (*model.Token, error)
	Last() (*model.Token, error)
	Find() ([]*model.Token, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Token, err error)
	FindInBatches(result *[]*model.Token, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Token) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) ITokenDo
	Assign(attrs ...field.AssignExpr) ITokenDo
	Joins(fields ...field.RelationField) ITokenDo
	Preload(fields ...field.RelationField) ITokenDo
	FirstOrInit() (*model.Token, error)
	FirstOrCreate() (*model.Token, error)
	FindByPage(offset int, limit int) (result []*model.Token, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) ITokenDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IUserDo interface {
	gen.SubQuery
	Debug() IUserDo
	WithContext(ctx context.Context) IUserDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IUserDo
	WriteDB() IUserDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IUserDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IUserDo
	Not(conds ...gen.Condition) IUserDo
	Or(conds ...gen.Condition) IUserDo
	Select(conds ...field.Expr) IUserDo
	Where(conds ...gen.Condition) IUserDo
	Order(conds ...field.Expr) IUserDo
	Distinct(cols ...field.Expr) IUserDo
	Omit(cols ...field.Expr) IUserDo
	Join(table schema.Tabler, on ...field.Expr) IUserDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo
	RightJoin(table schema.Tabler, on ...field.Expr) IUserDo
	Group(cols ...field.Expr) IUserDo
	Having(conds ...gen.Condition) IUserDo
	Limit(limit int) IUserDo
	Offset(offset int) IUserDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo
	Unscoped() IUserDo
	Create(values ...*model.User) error
	CreateInBatches(values []*model.User, batchSize int) error
	Save(values ...*model.User) error
	First() (*model.User, error)
	Take() (*model.User, error)
	Last() (*model.User, error)
	Find() ([]*model.User, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error)
	FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.User) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IUserDo
	Assign(attrs ...field.AssignExpr) IUserDo
	Joins(fields ...field.RelationField) IUserDo
	Preload(fields ...field.RelationField) IUserDo
	FirstOrInit() (*model.User, error)
	FirstOrCreate() (*model.User, error)
	FindByPage(offset int, limit int) (result []*model.User, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IUserDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type Query struct {
	Commit       commit
	DockerRepo   dockerRepo
	FileBlob     fileBlob
	FileManifest fileManifest
	Plugin       plugin
	Repository   repository
	Tag          tag
	Token        token
	User         user
	// contains filtered or unexported fields
}

type QueryTx struct {
	*Query
	Error error
}