model_gen

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type IAttendanceDo
• type IAttendanceResultDo
• type IAuthGroupDo
• type IAuthGroupPermissionsDo
• type IAuthPermissionDo
• type IAuthUserDo
• type IAuthUserGroupsDo
• type IAuthUserUserPermissionsDo
• type ICollectDocDemoDo
• type ICollectDocDo
• type ICollectDocImportantDo
• type ICollectDocParamsDo
• type ICollectDocResultDo
• type ICollectEventDo
• type IConfigDetailChangeHistoryDo
• type IConfigDetailDo
• type IConfigGroupDo
• type IDjangoAdminLogDo
• type IDjangoContentTypeDo
• type IDjangoMigrationsDo
• type IDjangoSessionDo
• type IDocGroupDo
• type ILdapGroupDo
• type IProjectDo
• type IReportGitcommitinfoDo
• type IReportGituserFixDo
• type IRoleDo
• type IRoleLdapGroupDo
• type IRoleMenuDo
• type ISysCodeDo
• type ISysMenuDo
• type ISysParamDo
• type ITemplateEventLogDo
• type IUserAccountDo
• type IUserChangeHistoryDo
• type IUserRoleDo
• type Query
  • func Use(db *gorm.DB, opts ...gen.DOOption) *Query
  • func (q *Query) Available() bool
  • func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx
  • func (q *Query) ReadDB() *Query
  • func (q *Query) ReplaceDB(db *gorm.DB) *Query
  • func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error
  • func (q *Query) WithContext(ctx context.Context) *queryCtx
  • func (q *Query) WriteDB() *Query
• type QueryTx
  • func (q *QueryTx) Commit() error
  • func (q *QueryTx) Rollback() error
  • func (q *QueryTx) RollbackTo(name string) error
  • func (q *QueryTx) SavePoint(name string) error

Variables

var (
	Q                         = new(Query)
	Attendance                *attendance
	AttendanceResult          *attendanceResult
	AuthGroup                 *authGroup
	AuthGroupPermissions      *authGroupPermissions
	AuthPermission            *authPermission
	AuthUser                  *authUser
	AuthUserGroups            *authUserGroups
	AuthUserUserPermissions   *authUserUserPermissions
	CollectDoc                *collectDoc
	CollectDocDemo            *collectDocDemo
	CollectDocImportant       *collectDocImportant
	CollectDocParams          *collectDocParams
	CollectDocResult          *collectDocResult
	CollectEvent              *collectEvent
	ConfigDetail              *configDetail
	ConfigDetailChangeHistory *configDetailChangeHistory
	ConfigGroup               *configGroup
	DjangoAdminLog            *djangoAdminLog
	DjangoContentType         *djangoContentType
	DjangoMigrations          *djangoMigrations
	DjangoSession             *djangoSession
	DocGroup                  *docGroup
	LdapGroup                 *ldapGroup
	Project                   *project
	ReportGitcommitinfo       *reportGitcommitinfo
	ReportGituserFix          *reportGituserFix
	Role                      *role
	RoleLdapGroup             *roleLdapGroup
	RoleMenu                  *roleMenu
	SysCode                   *sysCode
	SysMenu                   *sysMenu
	SysParam                  *sysParam
	TemplateEventLog          *templateEventLog
	UserAccount               *userAccount
	UserChangeHistory         *userChangeHistory
	UserRole                  *userRole
)

Functions

func SetDefault

func SetDefault(db *gorm.DB, opts ...gen.DOOption)

Types

type IAttendanceDo

type IAttendanceDo interface {
	gen.SubQuery
	Debug() IAttendanceDo
	WithContext(ctx context.Context) IAttendanceDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAttendanceDo
	WriteDB() IAttendanceDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAttendanceDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAttendanceDo
	Not(conds ...gen.Condition) IAttendanceDo
	Or(conds ...gen.Condition) IAttendanceDo
	Select(conds ...field.Expr) IAttendanceDo
	Where(conds ...gen.Condition) IAttendanceDo
	Order(conds ...field.Expr) IAttendanceDo
	Distinct(cols ...field.Expr) IAttendanceDo
	Omit(cols ...field.Expr) IAttendanceDo
	Join(table schema.Tabler, on ...field.Expr) IAttendanceDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAttendanceDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAttendanceDo
	Group(cols ...field.Expr) IAttendanceDo
	Having(conds ...gen.Condition) IAttendanceDo
	Limit(limit int) IAttendanceDo
	Offset(offset int) IAttendanceDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAttendanceDo
	Unscoped() IAttendanceDo
	Create(values ...*model.Attendance) error
	CreateInBatches(values []*model.Attendance, batchSize int) error
	Save(values ...*model.Attendance) error
	First() (*model.Attendance, error)
	Take() (*model.Attendance, error)
	Last() (*model.Attendance, error)
	Find() ([]*model.Attendance, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Attendance, err error)
	FindInBatches(result *[]*model.Attendance, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Attendance) (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) IAttendanceDo
	Assign(attrs ...field.AssignExpr) IAttendanceDo
	Joins(fields ...field.RelationField) IAttendanceDo
	Preload(fields ...field.RelationField) IAttendanceDo
	FirstOrInit() (*model.Attendance, error)
	FirstOrCreate() (*model.Attendance, error)
	FindByPage(offset int, limit int) (result []*model.Attendance, 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) IAttendanceDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAttendanceResultDo

type IAttendanceResultDo interface {
	gen.SubQuery
	Debug() IAttendanceResultDo
	WithContext(ctx context.Context) IAttendanceResultDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAttendanceResultDo
	WriteDB() IAttendanceResultDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAttendanceResultDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAttendanceResultDo
	Not(conds ...gen.Condition) IAttendanceResultDo
	Or(conds ...gen.Condition) IAttendanceResultDo
	Select(conds ...field.Expr) IAttendanceResultDo
	Where(conds ...gen.Condition) IAttendanceResultDo
	Order(conds ...field.Expr) IAttendanceResultDo
	Distinct(cols ...field.Expr) IAttendanceResultDo
	Omit(cols ...field.Expr) IAttendanceResultDo
	Join(table schema.Tabler, on ...field.Expr) IAttendanceResultDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAttendanceResultDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAttendanceResultDo
	Group(cols ...field.Expr) IAttendanceResultDo
	Having(conds ...gen.Condition) IAttendanceResultDo
	Limit(limit int) IAttendanceResultDo
	Offset(offset int) IAttendanceResultDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAttendanceResultDo
	Unscoped() IAttendanceResultDo
	Create(values ...*model.AttendanceResult) error
	CreateInBatches(values []*model.AttendanceResult, batchSize int) error
	Save(values ...*model.AttendanceResult) error
	First() (*model.AttendanceResult, error)
	Take() (*model.AttendanceResult, error)
	Last() (*model.AttendanceResult, error)
	Find() ([]*model.AttendanceResult, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AttendanceResult, err error)
	FindInBatches(result *[]*model.AttendanceResult, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AttendanceResult) (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) IAttendanceResultDo
	Assign(attrs ...field.AssignExpr) IAttendanceResultDo
	Joins(fields ...field.RelationField) IAttendanceResultDo
	Preload(fields ...field.RelationField) IAttendanceResultDo
	FirstOrInit() (*model.AttendanceResult, error)
	FirstOrCreate() (*model.AttendanceResult, error)
	FindByPage(offset int, limit int) (result []*model.AttendanceResult, 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) IAttendanceResultDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAuthGroupDo

type IAuthGroupDo interface {
	gen.SubQuery
	Debug() IAuthGroupDo
	WithContext(ctx context.Context) IAuthGroupDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAuthGroupDo
	WriteDB() IAuthGroupDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAuthGroupDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAuthGroupDo
	Not(conds ...gen.Condition) IAuthGroupDo
	Or(conds ...gen.Condition) IAuthGroupDo
	Select(conds ...field.Expr) IAuthGroupDo
	Where(conds ...gen.Condition) IAuthGroupDo
	Order(conds ...field.Expr) IAuthGroupDo
	Distinct(cols ...field.Expr) IAuthGroupDo
	Omit(cols ...field.Expr) IAuthGroupDo
	Join(table schema.Tabler, on ...field.Expr) IAuthGroupDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthGroupDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAuthGroupDo
	Group(cols ...field.Expr) IAuthGroupDo
	Having(conds ...gen.Condition) IAuthGroupDo
	Limit(limit int) IAuthGroupDo
	Offset(offset int) IAuthGroupDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthGroupDo
	Unscoped() IAuthGroupDo
	Create(values ...*model.AuthGroup) error
	CreateInBatches(values []*model.AuthGroup, batchSize int) error
	Save(values ...*model.AuthGroup) error
	First() (*model.AuthGroup, error)
	Take() (*model.AuthGroup, error)
	Last() (*model.AuthGroup, error)
	Find() ([]*model.AuthGroup, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthGroup, err error)
	FindInBatches(result *[]*model.AuthGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AuthGroup) (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) IAuthGroupDo
	Assign(attrs ...field.AssignExpr) IAuthGroupDo
	Joins(fields ...field.RelationField) IAuthGroupDo
	Preload(fields ...field.RelationField) IAuthGroupDo
	FirstOrInit() (*model.AuthGroup, error)
	FirstOrCreate() (*model.AuthGroup, error)
	FindByPage(offset int, limit int) (result []*model.AuthGroup, 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) IAuthGroupDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAuthGroupPermissionsDo

type IAuthGroupPermissionsDo interface {
	gen.SubQuery
	Debug() IAuthGroupPermissionsDo
	WithContext(ctx context.Context) IAuthGroupPermissionsDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAuthGroupPermissionsDo
	WriteDB() IAuthGroupPermissionsDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAuthGroupPermissionsDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAuthGroupPermissionsDo
	Not(conds ...gen.Condition) IAuthGroupPermissionsDo
	Or(conds ...gen.Condition) IAuthGroupPermissionsDo
	Select(conds ...field.Expr) IAuthGroupPermissionsDo
	Where(conds ...gen.Condition) IAuthGroupPermissionsDo
	Order(conds ...field.Expr) IAuthGroupPermissionsDo
	Distinct(cols ...field.Expr) IAuthGroupPermissionsDo
	Omit(cols ...field.Expr) IAuthGroupPermissionsDo
	Join(table schema.Tabler, on ...field.Expr) IAuthGroupPermissionsDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthGroupPermissionsDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAuthGroupPermissionsDo
	Group(cols ...field.Expr) IAuthGroupPermissionsDo
	Having(conds ...gen.Condition) IAuthGroupPermissionsDo
	Limit(limit int) IAuthGroupPermissionsDo
	Offset(offset int) IAuthGroupPermissionsDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthGroupPermissionsDo
	Unscoped() IAuthGroupPermissionsDo
	Create(values ...*model.AuthGroupPermissions) error
	CreateInBatches(values []*model.AuthGroupPermissions, batchSize int) error
	Save(values ...*model.AuthGroupPermissions) error
	First() (*model.AuthGroupPermissions, error)
	Take() (*model.AuthGroupPermissions, error)
	Last() (*model.AuthGroupPermissions, error)
	Find() ([]*model.AuthGroupPermissions, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthGroupPermissions, err error)
	FindInBatches(result *[]*model.AuthGroupPermissions, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AuthGroupPermissions) (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) IAuthGroupPermissionsDo
	Assign(attrs ...field.AssignExpr) IAuthGroupPermissionsDo
	Joins(fields ...field.RelationField) IAuthGroupPermissionsDo
	Preload(fields ...field.RelationField) IAuthGroupPermissionsDo
	FirstOrInit() (*model.AuthGroupPermissions, error)
	FirstOrCreate() (*model.AuthGroupPermissions, error)
	FindByPage(offset int, limit int) (result []*model.AuthGroupPermissions, 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) IAuthGroupPermissionsDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAuthPermissionDo

type IAuthPermissionDo interface {
	gen.SubQuery
	Debug() IAuthPermissionDo
	WithContext(ctx context.Context) IAuthPermissionDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAuthPermissionDo
	WriteDB() IAuthPermissionDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAuthPermissionDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAuthPermissionDo
	Not(conds ...gen.Condition) IAuthPermissionDo
	Or(conds ...gen.Condition) IAuthPermissionDo
	Select(conds ...field.Expr) IAuthPermissionDo
	Where(conds ...gen.Condition) IAuthPermissionDo
	Order(conds ...field.Expr) IAuthPermissionDo
	Distinct(cols ...field.Expr) IAuthPermissionDo
	Omit(cols ...field.Expr) IAuthPermissionDo
	Join(table schema.Tabler, on ...field.Expr) IAuthPermissionDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthPermissionDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAuthPermissionDo
	Group(cols ...field.Expr) IAuthPermissionDo
	Having(conds ...gen.Condition) IAuthPermissionDo
	Limit(limit int) IAuthPermissionDo
	Offset(offset int) IAuthPermissionDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthPermissionDo
	Unscoped() IAuthPermissionDo
	Create(values ...*model.AuthPermission) error
	CreateInBatches(values []*model.AuthPermission, batchSize int) error
	Save(values ...*model.AuthPermission) error
	First() (*model.AuthPermission, error)
	Take() (*model.AuthPermission, error)
	Last() (*model.AuthPermission, error)
	Find() ([]*model.AuthPermission, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthPermission, err error)
	FindInBatches(result *[]*model.AuthPermission, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AuthPermission) (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) IAuthPermissionDo
	Assign(attrs ...field.AssignExpr) IAuthPermissionDo
	Joins(fields ...field.RelationField) IAuthPermissionDo
	Preload(fields ...field.RelationField) IAuthPermissionDo
	FirstOrInit() (*model.AuthPermission, error)
	FirstOrCreate() (*model.AuthPermission, error)
	FindByPage(offset int, limit int) (result []*model.AuthPermission, 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) IAuthPermissionDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAuthUserDo

type IAuthUserDo interface {
	gen.SubQuery
	Debug() IAuthUserDo
	WithContext(ctx context.Context) IAuthUserDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAuthUserDo
	WriteDB() IAuthUserDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAuthUserDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAuthUserDo
	Not(conds ...gen.Condition) IAuthUserDo
	Or(conds ...gen.Condition) IAuthUserDo
	Select(conds ...field.Expr) IAuthUserDo
	Where(conds ...gen.Condition) IAuthUserDo
	Order(conds ...field.Expr) IAuthUserDo
	Distinct(cols ...field.Expr) IAuthUserDo
	Omit(cols ...field.Expr) IAuthUserDo
	Join(table schema.Tabler, on ...field.Expr) IAuthUserDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthUserDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAuthUserDo
	Group(cols ...field.Expr) IAuthUserDo
	Having(conds ...gen.Condition) IAuthUserDo
	Limit(limit int) IAuthUserDo
	Offset(offset int) IAuthUserDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthUserDo
	Unscoped() IAuthUserDo
	Create(values ...*model.AuthUser) error
	CreateInBatches(values []*model.AuthUser, batchSize int) error
	Save(values ...*model.AuthUser) error
	First() (*model.AuthUser, error)
	Take() (*model.AuthUser, error)
	Last() (*model.AuthUser, error)
	Find() ([]*model.AuthUser, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthUser, err error)
	FindInBatches(result *[]*model.AuthUser, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AuthUser) (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) IAuthUserDo
	Assign(attrs ...field.AssignExpr) IAuthUserDo
	Joins(fields ...field.RelationField) IAuthUserDo
	Preload(fields ...field.RelationField) IAuthUserDo
	FirstOrInit() (*model.AuthUser, error)
	FirstOrCreate() (*model.AuthUser, error)
	FindByPage(offset int, limit int) (result []*model.AuthUser, 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) IAuthUserDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAuthUserGroupsDo

type IAuthUserGroupsDo interface {
	gen.SubQuery
	Debug() IAuthUserGroupsDo
	WithContext(ctx context.Context) IAuthUserGroupsDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAuthUserGroupsDo
	WriteDB() IAuthUserGroupsDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAuthUserGroupsDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAuthUserGroupsDo
	Not(conds ...gen.Condition) IAuthUserGroupsDo
	Or(conds ...gen.Condition) IAuthUserGroupsDo
	Select(conds ...field.Expr) IAuthUserGroupsDo
	Where(conds ...gen.Condition) IAuthUserGroupsDo
	Order(conds ...field.Expr) IAuthUserGroupsDo
	Distinct(cols ...field.Expr) IAuthUserGroupsDo
	Omit(cols ...field.Expr) IAuthUserGroupsDo
	Join(table schema.Tabler, on ...field.Expr) IAuthUserGroupsDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthUserGroupsDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAuthUserGroupsDo
	Group(cols ...field.Expr) IAuthUserGroupsDo
	Having(conds ...gen.Condition) IAuthUserGroupsDo
	Limit(limit int) IAuthUserGroupsDo
	Offset(offset int) IAuthUserGroupsDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthUserGroupsDo
	Unscoped() IAuthUserGroupsDo
	Create(values ...*model.AuthUserGroups) error
	CreateInBatches(values []*model.AuthUserGroups, batchSize int) error
	Save(values ...*model.AuthUserGroups) error
	First() (*model.AuthUserGroups, error)
	Take() (*model.AuthUserGroups, error)
	Last() (*model.AuthUserGroups, error)
	Find() ([]*model.AuthUserGroups, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthUserGroups, err error)
	FindInBatches(result *[]*model.AuthUserGroups, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AuthUserGroups) (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) IAuthUserGroupsDo
	Assign(attrs ...field.AssignExpr) IAuthUserGroupsDo
	Joins(fields ...field.RelationField) IAuthUserGroupsDo
	Preload(fields ...field.RelationField) IAuthUserGroupsDo
	FirstOrInit() (*model.AuthUserGroups, error)
	FirstOrCreate() (*model.AuthUserGroups, error)
	FindByPage(offset int, limit int) (result []*model.AuthUserGroups, 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) IAuthUserGroupsDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAuthUserUserPermissionsDo

type IAuthUserUserPermissionsDo interface {
	gen.SubQuery
	Debug() IAuthUserUserPermissionsDo
	WithContext(ctx context.Context) IAuthUserUserPermissionsDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAuthUserUserPermissionsDo
	WriteDB() IAuthUserUserPermissionsDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAuthUserUserPermissionsDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAuthUserUserPermissionsDo
	Not(conds ...gen.Condition) IAuthUserUserPermissionsDo
	Or(conds ...gen.Condition) IAuthUserUserPermissionsDo
	Select(conds ...field.Expr) IAuthUserUserPermissionsDo
	Where(conds ...gen.Condition) IAuthUserUserPermissionsDo
	Order(conds ...field.Expr) IAuthUserUserPermissionsDo
	Distinct(cols ...field.Expr) IAuthUserUserPermissionsDo
	Omit(cols ...field.Expr) IAuthUserUserPermissionsDo
	Join(table schema.Tabler, on ...field.Expr) IAuthUserUserPermissionsDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAuthUserUserPermissionsDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAuthUserUserPermissionsDo
	Group(cols ...field.Expr) IAuthUserUserPermissionsDo
	Having(conds ...gen.Condition) IAuthUserUserPermissionsDo
	Limit(limit int) IAuthUserUserPermissionsDo
	Offset(offset int) IAuthUserUserPermissionsDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAuthUserUserPermissionsDo
	Unscoped() IAuthUserUserPermissionsDo
	Create(values ...*model.AuthUserUserPermissions) error
	CreateInBatches(values []*model.AuthUserUserPermissions, batchSize int) error
	Save(values ...*model.AuthUserUserPermissions) error
	First() (*model.AuthUserUserPermissions, error)
	Take() (*model.AuthUserUserPermissions, error)
	Last() (*model.AuthUserUserPermissions, error)
	Find() ([]*model.AuthUserUserPermissions, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AuthUserUserPermissions, err error)
	FindInBatches(result *[]*model.AuthUserUserPermissions, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AuthUserUserPermissions) (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) IAuthUserUserPermissionsDo
	Assign(attrs ...field.AssignExpr) IAuthUserUserPermissionsDo
	Joins(fields ...field.RelationField) IAuthUserUserPermissionsDo
	Preload(fields ...field.RelationField) IAuthUserUserPermissionsDo
	FirstOrInit() (*model.AuthUserUserPermissions, error)
	FirstOrCreate() (*model.AuthUserUserPermissions, error)
	FindByPage(offset int, limit int) (result []*model.AuthUserUserPermissions, 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) IAuthUserUserPermissionsDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ICollectDocDemoDo

type ICollectDocDemoDo interface {
	gen.SubQuery
	Debug() ICollectDocDemoDo
	WithContext(ctx context.Context) ICollectDocDemoDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ICollectDocDemoDo
	WriteDB() ICollectDocDemoDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ICollectDocDemoDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ICollectDocDemoDo
	Not(conds ...gen.Condition) ICollectDocDemoDo
	Or(conds ...gen.Condition) ICollectDocDemoDo
	Select(conds ...field.Expr) ICollectDocDemoDo
	Where(conds ...gen.Condition) ICollectDocDemoDo
	Order(conds ...field.Expr) ICollectDocDemoDo
	Distinct(cols ...field.Expr) ICollectDocDemoDo
	Omit(cols ...field.Expr) ICollectDocDemoDo
	Join(table schema.Tabler, on ...field.Expr) ICollectDocDemoDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ICollectDocDemoDo
	RightJoin(table schema.Tabler, on ...field.Expr) ICollectDocDemoDo
	Group(cols ...field.Expr) ICollectDocDemoDo
	Having(conds ...gen.Condition) ICollectDocDemoDo
	Limit(limit int) ICollectDocDemoDo
	Offset(offset int) ICollectDocDemoDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ICollectDocDemoDo
	Unscoped() ICollectDocDemoDo
	Create(values ...*model.CollectDocDemo) error
	CreateInBatches(values []*model.CollectDocDemo, batchSize int) error
	Save(values ...*model.CollectDocDemo) error
	First() (*model.CollectDocDemo, error)
	Take() (*model.CollectDocDemo, error)
	Last() (*model.CollectDocDemo, error)
	Find() ([]*model.CollectDocDemo, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.CollectDocDemo, err error)
	FindInBatches(result *[]*model.CollectDocDemo, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.CollectDocDemo) (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) ICollectDocDemoDo
	Assign(attrs ...field.AssignExpr) ICollectDocDemoDo
	Joins(fields ...field.RelationField) ICollectDocDemoDo
	Preload(fields ...field.RelationField) ICollectDocDemoDo
	FirstOrInit() (*model.CollectDocDemo, error)
	FirstOrCreate() (*model.CollectDocDemo, error)
	FindByPage(offset int, limit int) (result []*model.CollectDocDemo, 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) ICollectDocDemoDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ICollectDocDo

type ICollectDocDo interface {
	gen.SubQuery
	Debug() ICollectDocDo
	WithContext(ctx context.Context) ICollectDocDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ICollectDocDo
	WriteDB() ICollectDocDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ICollectDocDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ICollectDocDo
	Not(conds ...gen.Condition) ICollectDocDo
	Or(conds ...gen.Condition) ICollectDocDo
	Select(conds ...field.Expr) ICollectDocDo
	Where(conds ...gen.Condition) ICollectDocDo
	Order(conds ...field.Expr) ICollectDocDo
	Distinct(cols ...field.Expr) ICollectDocDo
	Omit(cols ...field.Expr) ICollectDocDo
	Join(table schema.Tabler, on ...field.Expr) ICollectDocDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ICollectDocDo
	RightJoin(table schema.Tabler, on ...field.Expr) ICollectDocDo
	Group(cols ...field.Expr) ICollectDocDo
	Having(conds ...gen.Condition) ICollectDocDo
	Limit(limit int) ICollectDocDo
	Offset(offset int) ICollectDocDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ICollectDocDo
	Unscoped() ICollectDocDo
	Create(values ...*model.CollectDoc) error
	CreateInBatches(values []*model.CollectDoc, batchSize int) error
	Save(values ...*model.CollectDoc) error
	First() (*model.CollectDoc, error)
	Take() (*model.CollectDoc, error)
	Last() (*model.CollectDoc, error)
	Find() ([]*model.CollectDoc, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.CollectDoc, err error)
	FindInBatches(result *[]*model.CollectDoc, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.CollectDoc) (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) ICollectDocDo
	Assign(attrs ...field.AssignExpr) ICollectDocDo
	Joins(fields ...field.RelationField) ICollectDocDo
	Preload(fields ...field.RelationField) ICollectDocDo
	FirstOrInit() (*model.CollectDoc, error)
	FirstOrCreate() (*model.CollectDoc, error)
	FindByPage(offset int, limit int) (result []*model.CollectDoc, 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) ICollectDocDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ICollectDocImportantDo

type ICollectDocImportantDo interface {
	gen.SubQuery
	Debug() ICollectDocImportantDo
	WithContext(ctx context.Context) ICollectDocImportantDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ICollectDocImportantDo
	WriteDB() ICollectDocImportantDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ICollectDocImportantDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ICollectDocImportantDo
	Not(conds ...gen.Condition) ICollectDocImportantDo
	Or(conds ...gen.Condition) ICollectDocImportantDo
	Select(conds ...field.Expr) ICollectDocImportantDo
	Where(conds ...gen.Condition) ICollectDocImportantDo
	Order(conds ...field.Expr) ICollectDocImportantDo
	Distinct(cols ...field.Expr) ICollectDocImportantDo
	Omit(cols ...field.Expr) ICollectDocImportantDo
	Join(table schema.Tabler, on ...field.Expr) ICollectDocImportantDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ICollectDocImportantDo
	RightJoin(table schema.Tabler, on ...field.Expr) ICollectDocImportantDo
	Group(cols ...field.Expr) ICollectDocImportantDo
	Having(conds ...gen.Condition) ICollectDocImportantDo
	Limit(limit int) ICollectDocImportantDo
	Offset(offset int) ICollectDocImportantDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ICollectDocImportantDo
	Unscoped() ICollectDocImportantDo
	Create(values ...*model.CollectDocImportant) error
	CreateInBatches(values []*model.CollectDocImportant, batchSize int) error
	Save(values ...*model.CollectDocImportant) error
	First() (*model.CollectDocImportant, error)
	Take() (*model.CollectDocImportant, error)
	Last() (*model.CollectDocImportant, error)
	Find() ([]*model.CollectDocImportant, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.CollectDocImportant, err error)
	FindInBatches(result *[]*model.CollectDocImportant, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.CollectDocImportant) (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) ICollectDocImportantDo
	Assign(attrs ...field.AssignExpr) ICollectDocImportantDo
	Joins(fields ...field.RelationField) ICollectDocImportantDo
	Preload(fields ...field.RelationField) ICollectDocImportantDo
	FirstOrInit() (*model.CollectDocImportant, error)
	FirstOrCreate() (*model.CollectDocImportant, error)
	FindByPage(offset int, limit int) (result []*model.CollectDocImportant, 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) ICollectDocImportantDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ICollectDocParamsDo

type ICollectDocParamsDo interface {
	gen.SubQuery
	Debug() ICollectDocParamsDo
	WithContext(ctx context.Context) ICollectDocParamsDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ICollectDocParamsDo
	WriteDB() ICollectDocParamsDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ICollectDocParamsDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ICollectDocParamsDo
	Not(conds ...gen.Condition) ICollectDocParamsDo
	Or(conds ...gen.Condition) ICollectDocParamsDo
	Select(conds ...field.Expr) ICollectDocParamsDo
	Where(conds ...gen.Condition) ICollectDocParamsDo
	Order(conds ...field.Expr) ICollectDocParamsDo
	Distinct(cols ...field.Expr) ICollectDocParamsDo
	Omit(cols ...field.Expr) ICollectDocParamsDo
	Join(table schema.Tabler, on ...field.Expr) ICollectDocParamsDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ICollectDocParamsDo
	RightJoin(table schema.Tabler, on ...field.Expr) ICollectDocParamsDo
	Group(cols ...field.Expr) ICollectDocParamsDo
	Having(conds ...gen.Condition) ICollectDocParamsDo
	Limit(limit int) ICollectDocParamsDo
	Offset(offset int) ICollectDocParamsDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ICollectDocParamsDo
	Unscoped() ICollectDocParamsDo
	Create(values ...*model.CollectDocParams) error
	CreateInBatches(values []*model.CollectDocParams, batchSize int) error
	Save(values ...*model.CollectDocParams) error
	First() (*model.CollectDocParams, error)
	Take() (*model.CollectDocParams, error)
	Last() (*model.CollectDocParams, error)
	Find() ([]*model.CollectDocParams, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.CollectDocParams, err error)
	FindInBatches(result *[]*model.CollectDocParams, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.CollectDocParams) (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) ICollectDocParamsDo
	Assign(attrs ...field.AssignExpr) ICollectDocParamsDo
	Joins(fields ...field.RelationField) ICollectDocParamsDo
	Preload(fields ...field.RelationField) ICollectDocParamsDo
	FirstOrInit() (*model.CollectDocParams, error)
	FirstOrCreate() (*model.CollectDocParams, error)
	FindByPage(offset int, limit int) (result []*model.CollectDocParams, 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) ICollectDocParamsDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ICollectDocResultDo

type ICollectDocResultDo interface {
	gen.SubQuery
	Debug() ICollectDocResultDo
	WithContext(ctx context.Context) ICollectDocResultDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ICollectDocResultDo
	WriteDB() ICollectDocResultDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ICollectDocResultDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ICollectDocResultDo
	Not(conds ...gen.Condition) ICollectDocResultDo
	Or(conds ...gen.Condition) ICollectDocResultDo
	Select(conds ...field.Expr) ICollectDocResultDo
	Where(conds ...gen.Condition) ICollectDocResultDo
	Order(conds ...field.Expr) ICollectDocResultDo
	Distinct(cols ...field.Expr) ICollectDocResultDo
	Omit(cols ...field.Expr) ICollectDocResultDo
	Join(table schema.Tabler, on ...field.Expr) ICollectDocResultDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ICollectDocResultDo
	RightJoin(table schema.Tabler, on ...field.Expr) ICollectDocResultDo
	Group(cols ...field.Expr) ICollectDocResultDo
	Having(conds ...gen.Condition) ICollectDocResultDo
	Limit(limit int) ICollectDocResultDo
	Offset(offset int) ICollectDocResultDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ICollectDocResultDo
	Unscoped() ICollectDocResultDo
	Create(values ...*model.CollectDocResult) error
	CreateInBatches(values []*model.CollectDocResult, batchSize int) error
	Save(values ...*model.CollectDocResult) error
	First() (*model.CollectDocResult, error)
	Take() (*model.CollectDocResult, error)
	Last() (*model.CollectDocResult, error)
	Find() ([]*model.CollectDocResult, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.CollectDocResult, err error)
	FindInBatches(result *[]*model.CollectDocResult, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.CollectDocResult) (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) ICollectDocResultDo
	Assign(attrs ...field.AssignExpr) ICollectDocResultDo
	Joins(fields ...field.RelationField) ICollectDocResultDo
	Preload(fields ...field.RelationField) ICollectDocResultDo
	FirstOrInit() (*model.CollectDocResult, error)
	FirstOrCreate() (*model.CollectDocResult, error)
	FindByPage(offset int, limit int) (result []*model.CollectDocResult, 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) ICollectDocResultDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ICollectEventDo

type ICollectEventDo interface {
	gen.SubQuery
	Debug() ICollectEventDo
	WithContext(ctx context.Context) ICollectEventDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ICollectEventDo
	WriteDB() ICollectEventDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ICollectEventDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ICollectEventDo
	Not(conds ...gen.Condition) ICollectEventDo
	Or(conds ...gen.Condition) ICollectEventDo
	Select(conds ...field.Expr) ICollectEventDo
	Where(conds ...gen.Condition) ICollectEventDo
	Order(conds ...field.Expr) ICollectEventDo
	Distinct(cols ...field.Expr) ICollectEventDo
	Omit(cols ...field.Expr) ICollectEventDo
	Join(table schema.Tabler, on ...field.Expr) ICollectEventDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ICollectEventDo
	RightJoin(table schema.Tabler, on ...field.Expr) ICollectEventDo
	Group(cols ...field.Expr) ICollectEventDo
	Having(conds ...gen.Condition) ICollectEventDo
	Limit(limit int) ICollectEventDo
	Offset(offset int) ICollectEventDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ICollectEventDo
	Unscoped() ICollectEventDo
	Create(values ...*model.CollectEvent) error
	CreateInBatches(values []*model.CollectEvent, batchSize int) error
	Save(values ...*model.CollectEvent) error
	First() (*model.CollectEvent, error)
	Take() (*model.CollectEvent, error)
	Last() (*model.CollectEvent, error)
	Find() ([]*model.CollectEvent, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.CollectEvent, err error)
	FindInBatches(result *[]*model.CollectEvent, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.CollectEvent) (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) ICollectEventDo
	Assign(attrs ...field.AssignExpr) ICollectEventDo
	Joins(fields ...field.RelationField) ICollectEventDo
	Preload(fields ...field.RelationField) ICollectEventDo
	FirstOrInit() (*model.CollectEvent, error)
	FirstOrCreate() (*model.CollectEvent, error)
	FindByPage(offset int, limit int) (result []*model.CollectEvent, 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) ICollectEventDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IConfigDetailChangeHistoryDo

type IConfigDetailChangeHistoryDo interface {
	gen.SubQuery
	Debug() IConfigDetailChangeHistoryDo
	WithContext(ctx context.Context) IConfigDetailChangeHistoryDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IConfigDetailChangeHistoryDo
	WriteDB() IConfigDetailChangeHistoryDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IConfigDetailChangeHistoryDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IConfigDetailChangeHistoryDo
	Not(conds ...gen.Condition) IConfigDetailChangeHistoryDo
	Or(conds ...gen.Condition) IConfigDetailChangeHistoryDo
	Select(conds ...field.Expr) IConfigDetailChangeHistoryDo
	Where(conds ...gen.Condition) IConfigDetailChangeHistoryDo
	Order(conds ...field.Expr) IConfigDetailChangeHistoryDo
	Distinct(cols ...field.Expr) IConfigDetailChangeHistoryDo
	Omit(cols ...field.Expr) IConfigDetailChangeHistoryDo
	Join(table schema.Tabler, on ...field.Expr) IConfigDetailChangeHistoryDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IConfigDetailChangeHistoryDo
	RightJoin(table schema.Tabler, on ...field.Expr) IConfigDetailChangeHistoryDo
	Group(cols ...field.Expr) IConfigDetailChangeHistoryDo
	Having(conds ...gen.Condition) IConfigDetailChangeHistoryDo
	Limit(limit int) IConfigDetailChangeHistoryDo
	Offset(offset int) IConfigDetailChangeHistoryDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IConfigDetailChangeHistoryDo
	Unscoped() IConfigDetailChangeHistoryDo
	Create(values ...*model.ConfigDetailChangeHistory) error
	CreateInBatches(values []*model.ConfigDetailChangeHistory, batchSize int) error
	Save(values ...*model.ConfigDetailChangeHistory) error
	First() (*model.ConfigDetailChangeHistory, error)
	Take() (*model.ConfigDetailChangeHistory, error)
	Last() (*model.ConfigDetailChangeHistory, error)
	Find() ([]*model.ConfigDetailChangeHistory, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ConfigDetailChangeHistory, err error)
	FindInBatches(result *[]*model.ConfigDetailChangeHistory, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.ConfigDetailChangeHistory) (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) IConfigDetailChangeHistoryDo
	Assign(attrs ...field.AssignExpr) IConfigDetailChangeHistoryDo
	Joins(fields ...field.RelationField) IConfigDetailChangeHistoryDo
	Preload(fields ...field.RelationField) IConfigDetailChangeHistoryDo
	FirstOrInit() (*model.ConfigDetailChangeHistory, error)
	FirstOrCreate() (*model.ConfigDetailChangeHistory, error)
	FindByPage(offset int, limit int) (result []*model.ConfigDetailChangeHistory, 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) IConfigDetailChangeHistoryDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IConfigDetailDo

type IConfigDetailDo interface {
	gen.SubQuery
	Debug() IConfigDetailDo
	WithContext(ctx context.Context) IConfigDetailDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IConfigDetailDo
	WriteDB() IConfigDetailDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IConfigDetailDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IConfigDetailDo
	Not(conds ...gen.Condition) IConfigDetailDo
	Or(conds ...gen.Condition) IConfigDetailDo
	Select(conds ...field.Expr) IConfigDetailDo
	Where(conds ...gen.Condition) IConfigDetailDo
	Order(conds ...field.Expr) IConfigDetailDo
	Distinct(cols ...field.Expr) IConfigDetailDo
	Omit(cols ...field.Expr) IConfigDetailDo
	Join(table schema.Tabler, on ...field.Expr) IConfigDetailDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IConfigDetailDo
	RightJoin(table schema.Tabler, on ...field.Expr) IConfigDetailDo
	Group(cols ...field.Expr) IConfigDetailDo
	Having(conds ...gen.Condition) IConfigDetailDo
	Limit(limit int) IConfigDetailDo
	Offset(offset int) IConfigDetailDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IConfigDetailDo
	Unscoped() IConfigDetailDo
	Create(values ...*model.ConfigDetail) error
	CreateInBatches(values []*model.ConfigDetail, batchSize int) error
	Save(values ...*model.ConfigDetail) error
	First() (*model.ConfigDetail, error)
	Take() (*model.ConfigDetail, error)
	Last() (*model.ConfigDetail, error)
	Find() ([]*model.ConfigDetail, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ConfigDetail, err error)
	FindInBatches(result *[]*model.ConfigDetail, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.ConfigDetail) (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) IConfigDetailDo
	Assign(attrs ...field.AssignExpr) IConfigDetailDo
	Joins(fields ...field.RelationField) IConfigDetailDo
	Preload(fields ...field.RelationField) IConfigDetailDo
	FirstOrInit() (*model.ConfigDetail, error)
	FirstOrCreate() (*model.ConfigDetail, error)
	FindByPage(offset int, limit int) (result []*model.ConfigDetail, 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) IConfigDetailDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IConfigGroupDo

type IConfigGroupDo interface {
	gen.SubQuery
	Debug() IConfigGroupDo
	WithContext(ctx context.Context) IConfigGroupDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IConfigGroupDo
	WriteDB() IConfigGroupDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IConfigGroupDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IConfigGroupDo
	Not(conds ...gen.Condition) IConfigGroupDo
	Or(conds ...gen.Condition) IConfigGroupDo
	Select(conds ...field.Expr) IConfigGroupDo
	Where(conds ...gen.Condition) IConfigGroupDo
	Order(conds ...field.Expr) IConfigGroupDo
	Distinct(cols ...field.Expr) IConfigGroupDo
	Omit(cols ...field.Expr) IConfigGroupDo
	Join(table schema.Tabler, on ...field.Expr) IConfigGroupDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IConfigGroupDo
	RightJoin(table schema.Tabler, on ...field.Expr) IConfigGroupDo
	Group(cols ...field.Expr) IConfigGroupDo
	Having(conds ...gen.Condition) IConfigGroupDo
	Limit(limit int) IConfigGroupDo
	Offset(offset int) IConfigGroupDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IConfigGroupDo
	Unscoped() IConfigGroupDo
	Create(values ...*model.ConfigGroup) error
	CreateInBatches(values []*model.ConfigGroup, batchSize int) error
	Save(values ...*model.ConfigGroup) error
	First() (*model.ConfigGroup, error)
	Take() (*model.ConfigGroup, error)
	Last() (*model.ConfigGroup, error)
	Find() ([]*model.ConfigGroup, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ConfigGroup, err error)
	FindInBatches(result *[]*model.ConfigGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.ConfigGroup) (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) IConfigGroupDo
	Assign(attrs ...field.AssignExpr) IConfigGroupDo
	Joins(fields ...field.RelationField) IConfigGroupDo
	Preload(fields ...field.RelationField) IConfigGroupDo
	FirstOrInit() (*model.ConfigGroup, error)
	FirstOrCreate() (*model.ConfigGroup, error)
	FindByPage(offset int, limit int) (result []*model.ConfigGroup, 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) IConfigGroupDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IDjangoAdminLogDo

type IDjangoAdminLogDo interface {
	gen.SubQuery
	Debug() IDjangoAdminLogDo
	WithContext(ctx context.Context) IDjangoAdminLogDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IDjangoAdminLogDo
	WriteDB() IDjangoAdminLogDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IDjangoAdminLogDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IDjangoAdminLogDo
	Not(conds ...gen.Condition) IDjangoAdminLogDo
	Or(conds ...gen.Condition) IDjangoAdminLogDo
	Select(conds ...field.Expr) IDjangoAdminLogDo
	Where(conds ...gen.Condition) IDjangoAdminLogDo
	Order(conds ...field.Expr) IDjangoAdminLogDo
	Distinct(cols ...field.Expr) IDjangoAdminLogDo
	Omit(cols ...field.Expr) IDjangoAdminLogDo
	Join(table schema.Tabler, on ...field.Expr) IDjangoAdminLogDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IDjangoAdminLogDo
	RightJoin(table schema.Tabler, on ...field.Expr) IDjangoAdminLogDo
	Group(cols ...field.Expr) IDjangoAdminLogDo
	Having(conds ...gen.Condition) IDjangoAdminLogDo
	Limit(limit int) IDjangoAdminLogDo
	Offset(offset int) IDjangoAdminLogDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IDjangoAdminLogDo
	Unscoped() IDjangoAdminLogDo
	Create(values ...*model.DjangoAdminLog) error
	CreateInBatches(values []*model.DjangoAdminLog, batchSize int) error
	Save(values ...*model.DjangoAdminLog) error
	First() (*model.DjangoAdminLog, error)
	Take() (*model.DjangoAdminLog, error)
	Last() (*model.DjangoAdminLog, error)
	Find() ([]*model.DjangoAdminLog, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DjangoAdminLog, err error)
	FindInBatches(result *[]*model.DjangoAdminLog, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.DjangoAdminLog) (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) IDjangoAdminLogDo
	Assign(attrs ...field.AssignExpr) IDjangoAdminLogDo
	Joins(fields ...field.RelationField) IDjangoAdminLogDo
	Preload(fields ...field.RelationField) IDjangoAdminLogDo
	FirstOrInit() (*model.DjangoAdminLog, error)
	FirstOrCreate() (*model.DjangoAdminLog, error)
	FindByPage(offset int, limit int) (result []*model.DjangoAdminLog, 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) IDjangoAdminLogDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IDjangoContentTypeDo

type IDjangoContentTypeDo interface {
	gen.SubQuery
	Debug() IDjangoContentTypeDo
	WithContext(ctx context.Context) IDjangoContentTypeDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IDjangoContentTypeDo
	WriteDB() IDjangoContentTypeDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IDjangoContentTypeDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IDjangoContentTypeDo
	Not(conds ...gen.Condition) IDjangoContentTypeDo
	Or(conds ...gen.Condition) IDjangoContentTypeDo
	Select(conds ...field.Expr) IDjangoContentTypeDo
	Where(conds ...gen.Condition) IDjangoContentTypeDo
	Order(conds ...field.Expr) IDjangoContentTypeDo
	Distinct(cols ...field.Expr) IDjangoContentTypeDo
	Omit(cols ...field.Expr) IDjangoContentTypeDo
	Join(table schema.Tabler, on ...field.Expr) IDjangoContentTypeDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IDjangoContentTypeDo
	RightJoin(table schema.Tabler, on ...field.Expr) IDjangoContentTypeDo
	Group(cols ...field.Expr) IDjangoContentTypeDo
	Having(conds ...gen.Condition) IDjangoContentTypeDo
	Limit(limit int) IDjangoContentTypeDo
	Offset(offset int) IDjangoContentTypeDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IDjangoContentTypeDo
	Unscoped() IDjangoContentTypeDo
	Create(values ...*model.DjangoContentType) error
	CreateInBatches(values []*model.DjangoContentType, batchSize int) error
	Save(values ...*model.DjangoContentType) error
	First() (*model.DjangoContentType, error)
	Take() (*model.DjangoContentType, error)
	Last() (*model.DjangoContentType, error)
	Find() ([]*model.DjangoContentType, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DjangoContentType, err error)
	FindInBatches(result *[]*model.DjangoContentType, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.DjangoContentType) (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) IDjangoContentTypeDo
	Assign(attrs ...field.AssignExpr) IDjangoContentTypeDo
	Joins(fields ...field.RelationField) IDjangoContentTypeDo
	Preload(fields ...field.RelationField) IDjangoContentTypeDo
	FirstOrInit() (*model.DjangoContentType, error)
	FirstOrCreate() (*model.DjangoContentType, error)
	FindByPage(offset int, limit int) (result []*model.DjangoContentType, 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) IDjangoContentTypeDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IDjangoMigrationsDo

type IDjangoMigrationsDo interface {
	gen.SubQuery
	Debug() IDjangoMigrationsDo
	WithContext(ctx context.Context) IDjangoMigrationsDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IDjangoMigrationsDo
	WriteDB() IDjangoMigrationsDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IDjangoMigrationsDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IDjangoMigrationsDo
	Not(conds ...gen.Condition) IDjangoMigrationsDo
	Or(conds ...gen.Condition) IDjangoMigrationsDo
	Select(conds ...field.Expr) IDjangoMigrationsDo
	Where(conds ...gen.Condition) IDjangoMigrationsDo
	Order(conds ...field.Expr) IDjangoMigrationsDo
	Distinct(cols ...field.Expr) IDjangoMigrationsDo
	Omit(cols ...field.Expr) IDjangoMigrationsDo
	Join(table schema.Tabler, on ...field.Expr) IDjangoMigrationsDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IDjangoMigrationsDo
	RightJoin(table schema.Tabler, on ...field.Expr) IDjangoMigrationsDo
	Group(cols ...field.Expr) IDjangoMigrationsDo
	Having(conds ...gen.Condition) IDjangoMigrationsDo
	Limit(limit int) IDjangoMigrationsDo
	Offset(offset int) IDjangoMigrationsDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IDjangoMigrationsDo
	Unscoped() IDjangoMigrationsDo
	Create(values ...*model.DjangoMigrations) error
	CreateInBatches(values []*model.DjangoMigrations, batchSize int) error
	Save(values ...*model.DjangoMigrations) error
	First() (*model.DjangoMigrations, error)
	Take() (*model.DjangoMigrations, error)
	Last() (*model.DjangoMigrations, error)
	Find() ([]*model.DjangoMigrations, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DjangoMigrations, err error)
	FindInBatches(result *[]*model.DjangoMigrations, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.DjangoMigrations) (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) IDjangoMigrationsDo
	Assign(attrs ...field.AssignExpr) IDjangoMigrationsDo
	Joins(fields ...field.RelationField) IDjangoMigrationsDo
	Preload(fields ...field.RelationField) IDjangoMigrationsDo
	FirstOrInit() (*model.DjangoMigrations, error)
	FirstOrCreate() (*model.DjangoMigrations, error)
	FindByPage(offset int, limit int) (result []*model.DjangoMigrations, 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) IDjangoMigrationsDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IDjangoSessionDo

type IDjangoSessionDo interface {
	gen.SubQuery
	Debug() IDjangoSessionDo
	WithContext(ctx context.Context) IDjangoSessionDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IDjangoSessionDo
	WriteDB() IDjangoSessionDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IDjangoSessionDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IDjangoSessionDo
	Not(conds ...gen.Condition) IDjangoSessionDo
	Or(conds ...gen.Condition) IDjangoSessionDo
	Select(conds ...field.Expr) IDjangoSessionDo
	Where(conds ...gen.Condition) IDjangoSessionDo
	Order(conds ...field.Expr) IDjangoSessionDo
	Distinct(cols ...field.Expr) IDjangoSessionDo
	Omit(cols ...field.Expr) IDjangoSessionDo
	Join(table schema.Tabler, on ...field.Expr) IDjangoSessionDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IDjangoSessionDo
	RightJoin(table schema.Tabler, on ...field.Expr) IDjangoSessionDo
	Group(cols ...field.Expr) IDjangoSessionDo
	Having(conds ...gen.Condition) IDjangoSessionDo
	Limit(limit int) IDjangoSessionDo
	Offset(offset int) IDjangoSessionDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IDjangoSessionDo
	Unscoped() IDjangoSessionDo
	Create(values ...*model.DjangoSession) error
	CreateInBatches(values []*model.DjangoSession, batchSize int) error
	Save(values ...*model.DjangoSession) error
	First() (*model.DjangoSession, error)
	Take() (*model.DjangoSession, error)
	Last() (*model.DjangoSession, error)
	Find() ([]*model.DjangoSession, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DjangoSession, err error)
	FindInBatches(result *[]*model.DjangoSession, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.DjangoSession) (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) IDjangoSessionDo
	Assign(attrs ...field.AssignExpr) IDjangoSessionDo
	Joins(fields ...field.RelationField) IDjangoSessionDo
	Preload(fields ...field.RelationField) IDjangoSessionDo
	FirstOrInit() (*model.DjangoSession, error)
	FirstOrCreate() (*model.DjangoSession, error)
	FindByPage(offset int, limit int) (result []*model.DjangoSession, 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) IDjangoSessionDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IDocGroupDo

type IDocGroupDo interface {
	gen.SubQuery
	Debug() IDocGroupDo
	WithContext(ctx context.Context) IDocGroupDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IDocGroupDo
	WriteDB() IDocGroupDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IDocGroupDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IDocGroupDo
	Not(conds ...gen.Condition) IDocGroupDo
	Or(conds ...gen.Condition) IDocGroupDo
	Select(conds ...field.Expr) IDocGroupDo
	Where(conds ...gen.Condition) IDocGroupDo
	Order(conds ...field.Expr) IDocGroupDo
	Distinct(cols ...field.Expr) IDocGroupDo
	Omit(cols ...field.Expr) IDocGroupDo
	Join(table schema.Tabler, on ...field.Expr) IDocGroupDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IDocGroupDo
	RightJoin(table schema.Tabler, on ...field.Expr) IDocGroupDo
	Group(cols ...field.Expr) IDocGroupDo
	Having(conds ...gen.Condition) IDocGroupDo
	Limit(limit int) IDocGroupDo
	Offset(offset int) IDocGroupDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IDocGroupDo
	Unscoped() IDocGroupDo
	Create(values ...*model.DocGroup) error
	CreateInBatches(values []*model.DocGroup, batchSize int) error
	Save(values ...*model.DocGroup) error
	First() (*model.DocGroup, error)
	Take() (*model.DocGroup, error)
	Last() (*model.DocGroup, error)
	Find() ([]*model.DocGroup, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DocGroup, err error)
	FindInBatches(result *[]*model.DocGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.DocGroup) (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) IDocGroupDo
	Assign(attrs ...field.AssignExpr) IDocGroupDo
	Joins(fields ...field.RelationField) IDocGroupDo
	Preload(fields ...field.RelationField) IDocGroupDo
	FirstOrInit() (*model.DocGroup, error)
	FirstOrCreate() (*model.DocGroup, error)
	FindByPage(offset int, limit int) (result []*model.DocGroup, 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) IDocGroupDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ILdapGroupDo

type ILdapGroupDo interface {
	gen.SubQuery
	Debug() ILdapGroupDo
	WithContext(ctx context.Context) ILdapGroupDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ILdapGroupDo
	WriteDB() ILdapGroupDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ILdapGroupDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ILdapGroupDo
	Not(conds ...gen.Condition) ILdapGroupDo
	Or(conds ...gen.Condition) ILdapGroupDo
	Select(conds ...field.Expr) ILdapGroupDo
	Where(conds ...gen.Condition) ILdapGroupDo
	Order(conds ...field.Expr) ILdapGroupDo
	Distinct(cols ...field.Expr) ILdapGroupDo
	Omit(cols ...field.Expr) ILdapGroupDo
	Join(table schema.Tabler, on ...field.Expr) ILdapGroupDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ILdapGroupDo
	RightJoin(table schema.Tabler, on ...field.Expr) ILdapGroupDo
	Group(cols ...field.Expr) ILdapGroupDo
	Having(conds ...gen.Condition) ILdapGroupDo
	Limit(limit int) ILdapGroupDo
	Offset(offset int) ILdapGroupDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ILdapGroupDo
	Unscoped() ILdapGroupDo
	Create(values ...*model.LdapGroup) error
	CreateInBatches(values []*model.LdapGroup, batchSize int) error
	Save(values ...*model.LdapGroup) error
	First() (*model.LdapGroup, error)
	Take() (*model.LdapGroup, error)
	Last() (*model.LdapGroup, error)
	Find() ([]*model.LdapGroup, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.LdapGroup, err error)
	FindInBatches(result *[]*model.LdapGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.LdapGroup) (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) ILdapGroupDo
	Assign(attrs ...field.AssignExpr) ILdapGroupDo
	Joins(fields ...field.RelationField) ILdapGroupDo
	Preload(fields ...field.RelationField) ILdapGroupDo
	FirstOrInit() (*model.LdapGroup, error)
	FirstOrCreate() (*model.LdapGroup, error)
	FindByPage(offset int, limit int) (result []*model.LdapGroup, 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) ILdapGroupDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IProjectDo

type IProjectDo interface {
	gen.SubQuery
	Debug() IProjectDo
	WithContext(ctx context.Context) IProjectDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IProjectDo
	WriteDB() IProjectDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IProjectDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IProjectDo
	Not(conds ...gen.Condition) IProjectDo
	Or(conds ...gen.Condition) IProjectDo
	Select(conds ...field.Expr) IProjectDo
	Where(conds ...gen.Condition) IProjectDo
	Order(conds ...field.Expr) IProjectDo
	Distinct(cols ...field.Expr) IProjectDo
	Omit(cols ...field.Expr) IProjectDo
	Join(table schema.Tabler, on ...field.Expr) IProjectDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IProjectDo
	RightJoin(table schema.Tabler, on ...field.Expr) IProjectDo
	Group(cols ...field.Expr) IProjectDo
	Having(conds ...gen.Condition) IProjectDo
	Limit(limit int) IProjectDo
	Offset(offset int) IProjectDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IProjectDo
	Unscoped() IProjectDo
	Create(values ...*model.Project) error
	CreateInBatches(values []*model.Project, batchSize int) error
	Save(values ...*model.Project) error
	First() (*model.Project, error)
	Take() (*model.Project, error)
	Last() (*model.Project, error)
	Find() ([]*model.Project, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Project, err error)
	FindInBatches(result *[]*model.Project, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Project) (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) IProjectDo
	Assign(attrs ...field.AssignExpr) IProjectDo
	Joins(fields ...field.RelationField) IProjectDo
	Preload(fields ...field.RelationField) IProjectDo
	FirstOrInit() (*model.Project, error)
	FirstOrCreate() (*model.Project, error)
	FindByPage(offset int, limit int) (result []*model.Project, 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) IProjectDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IReportGitcommitinfoDo

type IReportGitcommitinfoDo interface {
	gen.SubQuery
	Debug() IReportGitcommitinfoDo
	WithContext(ctx context.Context) IReportGitcommitinfoDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IReportGitcommitinfoDo
	WriteDB() IReportGitcommitinfoDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IReportGitcommitinfoDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IReportGitcommitinfoDo
	Not(conds ...gen.Condition) IReportGitcommitinfoDo
	Or(conds ...gen.Condition) IReportGitcommitinfoDo
	Select(conds ...field.Expr) IReportGitcommitinfoDo
	Where(conds ...gen.Condition) IReportGitcommitinfoDo
	Order(conds ...field.Expr) IReportGitcommitinfoDo
	Distinct(cols ...field.Expr) IReportGitcommitinfoDo
	Omit(cols ...field.Expr) IReportGitcommitinfoDo
	Join(table schema.Tabler, on ...field.Expr) IReportGitcommitinfoDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IReportGitcommitinfoDo
	RightJoin(table schema.Tabler, on ...field.Expr) IReportGitcommitinfoDo
	Group(cols ...field.Expr) IReportGitcommitinfoDo
	Having(conds ...gen.Condition) IReportGitcommitinfoDo
	Limit(limit int) IReportGitcommitinfoDo
	Offset(offset int) IReportGitcommitinfoDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IReportGitcommitinfoDo
	Unscoped() IReportGitcommitinfoDo
	Create(values ...*model.ReportGitcommitinfo) error
	CreateInBatches(values []*model.ReportGitcommitinfo, batchSize int) error
	Save(values ...*model.ReportGitcommitinfo) error
	First() (*model.ReportGitcommitinfo, error)
	Take() (*model.ReportGitcommitinfo, error)
	Last() (*model.ReportGitcommitinfo, error)
	Find() ([]*model.ReportGitcommitinfo, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ReportGitcommitinfo, err error)
	FindInBatches(result *[]*model.ReportGitcommitinfo, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.ReportGitcommitinfo) (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) IReportGitcommitinfoDo
	Assign(attrs ...field.AssignExpr) IReportGitcommitinfoDo
	Joins(fields ...field.RelationField) IReportGitcommitinfoDo
	Preload(fields ...field.RelationField) IReportGitcommitinfoDo
	FirstOrInit() (*model.ReportGitcommitinfo, error)
	FirstOrCreate() (*model.ReportGitcommitinfo, error)
	FindByPage(offset int, limit int) (result []*model.ReportGitcommitinfo, 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) IReportGitcommitinfoDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IReportGituserFixDo

type IReportGituserFixDo interface {
	gen.SubQuery
	Debug() IReportGituserFixDo
	WithContext(ctx context.Context) IReportGituserFixDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IReportGituserFixDo
	WriteDB() IReportGituserFixDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IReportGituserFixDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IReportGituserFixDo
	Not(conds ...gen.Condition) IReportGituserFixDo
	Or(conds ...gen.Condition) IReportGituserFixDo
	Select(conds ...field.Expr) IReportGituserFixDo
	Where(conds ...gen.Condition) IReportGituserFixDo
	Order(conds ...field.Expr) IReportGituserFixDo
	Distinct(cols ...field.Expr) IReportGituserFixDo
	Omit(cols ...field.Expr) IReportGituserFixDo
	Join(table schema.Tabler, on ...field.Expr) IReportGituserFixDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IReportGituserFixDo
	RightJoin(table schema.Tabler, on ...field.Expr) IReportGituserFixDo
	Group(cols ...field.Expr) IReportGituserFixDo
	Having(conds ...gen.Condition) IReportGituserFixDo
	Limit(limit int) IReportGituserFixDo
	Offset(offset int) IReportGituserFixDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IReportGituserFixDo
	Unscoped() IReportGituserFixDo
	Create(values ...*model.ReportGituserFix) error
	CreateInBatches(values []*model.ReportGituserFix, batchSize int) error
	Save(values ...*model.ReportGituserFix) error
	First() (*model.ReportGituserFix, error)
	Take() (*model.ReportGituserFix, error)
	Last() (*model.ReportGituserFix, error)
	Find() ([]*model.ReportGituserFix, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.ReportGituserFix, err error)
	FindInBatches(result *[]*model.ReportGituserFix, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.ReportGituserFix) (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) IReportGituserFixDo
	Assign(attrs ...field.AssignExpr) IReportGituserFixDo
	Joins(fields ...field.RelationField) IReportGituserFixDo
	Preload(fields ...field.RelationField) IReportGituserFixDo
	FirstOrInit() (*model.ReportGituserFix, error)
	FirstOrCreate() (*model.ReportGituserFix, error)
	FindByPage(offset int, limit int) (result []*model.ReportGituserFix, 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) IReportGituserFixDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IRoleDo

type IRoleDo interface {
	gen.SubQuery
	Debug() IRoleDo
	WithContext(ctx context.Context) IRoleDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IRoleDo
	WriteDB() IRoleDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IRoleDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IRoleDo
	Not(conds ...gen.Condition) IRoleDo
	Or(conds ...gen.Condition) IRoleDo
	Select(conds ...field.Expr) IRoleDo
	Where(conds ...gen.Condition) IRoleDo
	Order(conds ...field.Expr) IRoleDo
	Distinct(cols ...field.Expr) IRoleDo
	Omit(cols ...field.Expr) IRoleDo
	Join(table schema.Tabler, on ...field.Expr) IRoleDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IRoleDo
	RightJoin(table schema.Tabler, on ...field.Expr) IRoleDo
	Group(cols ...field.Expr) IRoleDo
	Having(conds ...gen.Condition) IRoleDo
	Limit(limit int) IRoleDo
	Offset(offset int) IRoleDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IRoleDo
	Unscoped() IRoleDo
	Create(values ...*model.Role) error
	CreateInBatches(values []*model.Role, batchSize int) error
	Save(values ...*model.Role) error
	First() (*model.Role, error)
	Take() (*model.Role, error)
	Last() (*model.Role, error)
	Find() ([]*model.Role, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Role, err error)
	FindInBatches(result *[]*model.Role, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Role) (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) IRoleDo
	Assign(attrs ...field.AssignExpr) IRoleDo
	Joins(fields ...field.RelationField) IRoleDo
	Preload(fields ...field.RelationField) IRoleDo
	FirstOrInit() (*model.Role, error)
	FirstOrCreate() (*model.Role, error)
	FindByPage(offset int, limit int) (result []*model.Role, 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) IRoleDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IRoleLdapGroupDo

type IRoleLdapGroupDo interface {
	gen.SubQuery
	Debug() IRoleLdapGroupDo
	WithContext(ctx context.Context) IRoleLdapGroupDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IRoleLdapGroupDo
	WriteDB() IRoleLdapGroupDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IRoleLdapGroupDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IRoleLdapGroupDo
	Not(conds ...gen.Condition) IRoleLdapGroupDo
	Or(conds ...gen.Condition) IRoleLdapGroupDo
	Select(conds ...field.Expr) IRoleLdapGroupDo
	Where(conds ...gen.Condition) IRoleLdapGroupDo
	Order(conds ...field.Expr) IRoleLdapGroupDo
	Distinct(cols ...field.Expr) IRoleLdapGroupDo
	Omit(cols ...field.Expr) IRoleLdapGroupDo
	Join(table schema.Tabler, on ...field.Expr) IRoleLdapGroupDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IRoleLdapGroupDo
	RightJoin(table schema.Tabler, on ...field.Expr) IRoleLdapGroupDo
	Group(cols ...field.Expr) IRoleLdapGroupDo
	Having(conds ...gen.Condition) IRoleLdapGroupDo
	Limit(limit int) IRoleLdapGroupDo
	Offset(offset int) IRoleLdapGroupDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IRoleLdapGroupDo
	Unscoped() IRoleLdapGroupDo
	Create(values ...*model.RoleLdapGroup) error
	CreateInBatches(values []*model.RoleLdapGroup, batchSize int) error
	Save(values ...*model.RoleLdapGroup) error
	First() (*model.RoleLdapGroup, error)
	Take() (*model.RoleLdapGroup, error)
	Last() (*model.RoleLdapGroup, error)
	Find() ([]*model.RoleLdapGroup, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.RoleLdapGroup, err error)
	FindInBatches(result *[]*model.RoleLdapGroup, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.RoleLdapGroup) (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) IRoleLdapGroupDo
	Assign(attrs ...field.AssignExpr) IRoleLdapGroupDo
	Joins(fields ...field.RelationField) IRoleLdapGroupDo
	Preload(fields ...field.RelationField) IRoleLdapGroupDo
	FirstOrInit() (*model.RoleLdapGroup, error)
	FirstOrCreate() (*model.RoleLdapGroup, error)
	FindByPage(offset int, limit int) (result []*model.RoleLdapGroup, 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) IRoleLdapGroupDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IRoleMenuDo

type IRoleMenuDo interface {
	gen.SubQuery
	Debug() IRoleMenuDo
	WithContext(ctx context.Context) IRoleMenuDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IRoleMenuDo
	WriteDB() IRoleMenuDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IRoleMenuDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IRoleMenuDo
	Not(conds ...gen.Condition) IRoleMenuDo
	Or(conds ...gen.Condition) IRoleMenuDo
	Select(conds ...field.Expr) IRoleMenuDo
	Where(conds ...gen.Condition) IRoleMenuDo
	Order(conds ...field.Expr) IRoleMenuDo
	Distinct(cols ...field.Expr) IRoleMenuDo
	Omit(cols ...field.Expr) IRoleMenuDo
	Join(table schema.Tabler, on ...field.Expr) IRoleMenuDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IRoleMenuDo
	RightJoin(table schema.Tabler, on ...field.Expr) IRoleMenuDo
	Group(cols ...field.Expr) IRoleMenuDo
	Having(conds ...gen.Condition) IRoleMenuDo
	Limit(limit int) IRoleMenuDo
	Offset(offset int) IRoleMenuDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IRoleMenuDo
	Unscoped() IRoleMenuDo
	Create(values ...*model.RoleMenu) error
	CreateInBatches(values []*model.RoleMenu, batchSize int) error
	Save(values ...*model.RoleMenu) error
	First() (*model.RoleMenu, error)
	Take() (*model.RoleMenu, error)
	Last() (*model.RoleMenu, error)
	Find() ([]*model.RoleMenu, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.RoleMenu, err error)
	FindInBatches(result *[]*model.RoleMenu, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.RoleMenu) (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) IRoleMenuDo
	Assign(attrs ...field.AssignExpr) IRoleMenuDo
	Joins(fields ...field.RelationField) IRoleMenuDo
	Preload(fields ...field.RelationField) IRoleMenuDo
	FirstOrInit() (*model.RoleMenu, error)
	FirstOrCreate() (*model.RoleMenu, error)
	FindByPage(offset int, limit int) (result []*model.RoleMenu, 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) IRoleMenuDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ISysCodeDo

type ISysCodeDo interface {
	gen.SubQuery
	Debug() ISysCodeDo
	WithContext(ctx context.Context) ISysCodeDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ISysCodeDo
	WriteDB() ISysCodeDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ISysCodeDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ISysCodeDo
	Not(conds ...gen.Condition) ISysCodeDo
	Or(conds ...gen.Condition) ISysCodeDo
	Select(conds ...field.Expr) ISysCodeDo
	Where(conds ...gen.Condition) ISysCodeDo
	Order(conds ...field.Expr) ISysCodeDo
	Distinct(cols ...field.Expr) ISysCodeDo
	Omit(cols ...field.Expr) ISysCodeDo
	Join(table schema.Tabler, on ...field.Expr) ISysCodeDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ISysCodeDo
	RightJoin(table schema.Tabler, on ...field.Expr) ISysCodeDo
	Group(cols ...field.Expr) ISysCodeDo
	Having(conds ...gen.Condition) ISysCodeDo
	Limit(limit int) ISysCodeDo
	Offset(offset int) ISysCodeDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ISysCodeDo
	Unscoped() ISysCodeDo
	Create(values ...*model.SysCode) error
	CreateInBatches(values []*model.SysCode, batchSize int) error
	Save(values ...*model.SysCode) error
	First() (*model.SysCode, error)
	Take() (*model.SysCode, error)
	Last() (*model.SysCode, error)
	Find() ([]*model.SysCode, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.SysCode, err error)
	FindInBatches(result *[]*model.SysCode, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.SysCode) (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) ISysCodeDo
	Assign(attrs ...field.AssignExpr) ISysCodeDo
	Joins(fields ...field.RelationField) ISysCodeDo
	Preload(fields ...field.RelationField) ISysCodeDo
	FirstOrInit() (*model.SysCode, error)
	FirstOrCreate() (*model.SysCode, error)
	FindByPage(offset int, limit int) (result []*model.SysCode, 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) ISysCodeDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ISysMenuDo

type ISysMenuDo interface {
	gen.SubQuery
	Debug() ISysMenuDo
	WithContext(ctx context.Context) ISysMenuDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ISysMenuDo
	WriteDB() ISysMenuDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ISysMenuDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ISysMenuDo
	Not(conds ...gen.Condition) ISysMenuDo
	Or(conds ...gen.Condition) ISysMenuDo
	Select(conds ...field.Expr) ISysMenuDo
	Where(conds ...gen.Condition) ISysMenuDo
	Order(conds ...field.Expr) ISysMenuDo
	Distinct(cols ...field.Expr) ISysMenuDo
	Omit(cols ...field.Expr) ISysMenuDo
	Join(table schema.Tabler, on ...field.Expr) ISysMenuDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ISysMenuDo
	RightJoin(table schema.Tabler, on ...field.Expr) ISysMenuDo
	Group(cols ...field.Expr) ISysMenuDo
	Having(conds ...gen.Condition) ISysMenuDo
	Limit(limit int) ISysMenuDo
	Offset(offset int) ISysMenuDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ISysMenuDo
	Unscoped() ISysMenuDo
	Create(values ...*model.SysMenu) error
	CreateInBatches(values []*model.SysMenu, batchSize int) error
	Save(values ...*model.SysMenu) error
	First() (*model.SysMenu, error)
	Take() (*model.SysMenu, error)
	Last() (*model.SysMenu, error)
	Find() ([]*model.SysMenu, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.SysMenu, err error)
	FindInBatches(result *[]*model.SysMenu, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.SysMenu) (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) ISysMenuDo
	Assign(attrs ...field.AssignExpr) ISysMenuDo
	Joins(fields ...field.RelationField) ISysMenuDo
	Preload(fields ...field.RelationField) ISysMenuDo
	FirstOrInit() (*model.SysMenu, error)
	FirstOrCreate() (*model.SysMenu, error)
	FindByPage(offset int, limit int) (result []*model.SysMenu, 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) ISysMenuDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ISysParamDo

type ISysParamDo interface {
	gen.SubQuery
	Debug() ISysParamDo
	WithContext(ctx context.Context) ISysParamDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ISysParamDo
	WriteDB() ISysParamDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ISysParamDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ISysParamDo
	Not(conds ...gen.Condition) ISysParamDo
	Or(conds ...gen.Condition) ISysParamDo
	Select(conds ...field.Expr) ISysParamDo
	Where(conds ...gen.Condition) ISysParamDo
	Order(conds ...field.Expr) ISysParamDo
	Distinct(cols ...field.Expr) ISysParamDo
	Omit(cols ...field.Expr) ISysParamDo
	Join(table schema.Tabler, on ...field.Expr) ISysParamDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ISysParamDo
	RightJoin(table schema.Tabler, on ...field.Expr) ISysParamDo
	Group(cols ...field.Expr) ISysParamDo
	Having(conds ...gen.Condition) ISysParamDo
	Limit(limit int) ISysParamDo
	Offset(offset int) ISysParamDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ISysParamDo
	Unscoped() ISysParamDo
	Create(values ...*model.SysParam) error
	CreateInBatches(values []*model.SysParam, batchSize int) error
	Save(values ...*model.SysParam) error
	First() (*model.SysParam, error)
	Take() (*model.SysParam, error)
	Last() (*model.SysParam, error)
	Find() ([]*model.SysParam, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.SysParam, err error)
	FindInBatches(result *[]*model.SysParam, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.SysParam) (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) ISysParamDo
	Assign(attrs ...field.AssignExpr) ISysParamDo
	Joins(fields ...field.RelationField) ISysParamDo
	Preload(fields ...field.RelationField) ISysParamDo
	FirstOrInit() (*model.SysParam, error)
	FirstOrCreate() (*model.SysParam, error)
	FindByPage(offset int, limit int) (result []*model.SysParam, 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) ISysParamDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ITemplateEventLogDo

type ITemplateEventLogDo interface {
	gen.SubQuery
	Debug() ITemplateEventLogDo
	WithContext(ctx context.Context) ITemplateEventLogDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ITemplateEventLogDo
	WriteDB() ITemplateEventLogDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ITemplateEventLogDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ITemplateEventLogDo
	Not(conds ...gen.Condition) ITemplateEventLogDo
	Or(conds ...gen.Condition) ITemplateEventLogDo
	Select(conds ...field.Expr) ITemplateEventLogDo
	Where(conds ...gen.Condition) ITemplateEventLogDo
	Order(conds ...field.Expr) ITemplateEventLogDo
	Distinct(cols ...field.Expr) ITemplateEventLogDo
	Omit(cols ...field.Expr) ITemplateEventLogDo
	Join(table schema.Tabler, on ...field.Expr) ITemplateEventLogDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ITemplateEventLogDo
	RightJoin(table schema.Tabler, on ...field.Expr) ITemplateEventLogDo
	Group(cols ...field.Expr) ITemplateEventLogDo
	Having(conds ...gen.Condition) ITemplateEventLogDo
	Limit(limit int) ITemplateEventLogDo
	Offset(offset int) ITemplateEventLogDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ITemplateEventLogDo
	Unscoped() ITemplateEventLogDo
	Create(values ...*model.TemplateEventLog) error
	CreateInBatches(values []*model.TemplateEventLog, batchSize int) error
	Save(values ...*model.TemplateEventLog) error
	First() (*model.TemplateEventLog, error)
	Take() (*model.TemplateEventLog, error)
	Last() (*model.TemplateEventLog, error)
	Find() ([]*model.TemplateEventLog, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.TemplateEventLog, err error)
	FindInBatches(result *[]*model.TemplateEventLog, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.TemplateEventLog) (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) ITemplateEventLogDo
	Assign(attrs ...field.AssignExpr) ITemplateEventLogDo
	Joins(fields ...field.RelationField) ITemplateEventLogDo
	Preload(fields ...field.RelationField) ITemplateEventLogDo
	FirstOrInit() (*model.TemplateEventLog, error)
	FirstOrCreate() (*model.TemplateEventLog, error)
	FindByPage(offset int, limit int) (result []*model.TemplateEventLog, 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) ITemplateEventLogDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IUserAccountDo

type IUserAccountDo interface {
	gen.SubQuery
	Debug() IUserAccountDo
	WithContext(ctx context.Context) IUserAccountDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IUserAccountDo
	WriteDB() IUserAccountDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IUserAccountDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IUserAccountDo
	Not(conds ...gen.Condition) IUserAccountDo
	Or(conds ...gen.Condition) IUserAccountDo
	Select(conds ...field.Expr) IUserAccountDo
	Where(conds ...gen.Condition) IUserAccountDo
	Order(conds ...field.Expr) IUserAccountDo
	Distinct(cols ...field.Expr) IUserAccountDo
	Omit(cols ...field.Expr) IUserAccountDo
	Join(table schema.Tabler, on ...field.Expr) IUserAccountDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IUserAccountDo
	RightJoin(table schema.Tabler, on ...field.Expr) IUserAccountDo
	Group(cols ...field.Expr) IUserAccountDo
	Having(conds ...gen.Condition) IUserAccountDo
	Limit(limit int) IUserAccountDo
	Offset(offset int) IUserAccountDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserAccountDo
	Unscoped() IUserAccountDo
	Create(values ...*model.UserAccount) error
	CreateInBatches(values []*model.UserAccount, batchSize int) error
	Save(values ...*model.UserAccount) error
	First() (*model.UserAccount, error)
	Take() (*model.UserAccount, error)
	Last() (*model.UserAccount, error)
	Find() ([]*model.UserAccount, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.UserAccount, err error)
	FindInBatches(result *[]*model.UserAccount, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.UserAccount) (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) IUserAccountDo
	Assign(attrs ...field.AssignExpr) IUserAccountDo
	Joins(fields ...field.RelationField) IUserAccountDo
	Preload(fields ...field.RelationField) IUserAccountDo
	FirstOrInit() (*model.UserAccount, error)
	FirstOrCreate() (*model.UserAccount, error)
	FindByPage(offset int, limit int) (result []*model.UserAccount, 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) IUserAccountDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IUserChangeHistoryDo

type IUserChangeHistoryDo interface {
	gen.SubQuery
	Debug() IUserChangeHistoryDo
	WithContext(ctx context.Context) IUserChangeHistoryDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IUserChangeHistoryDo
	WriteDB() IUserChangeHistoryDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IUserChangeHistoryDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IUserChangeHistoryDo
	Not(conds ...gen.Condition) IUserChangeHistoryDo
	Or(conds ...gen.Condition) IUserChangeHistoryDo
	Select(conds ...field.Expr) IUserChangeHistoryDo
	Where(conds ...gen.Condition) IUserChangeHistoryDo
	Order(conds ...field.Expr) IUserChangeHistoryDo
	Distinct(cols ...field.Expr) IUserChangeHistoryDo
	Omit(cols ...field.Expr) IUserChangeHistoryDo
	Join(table schema.Tabler, on ...field.Expr) IUserChangeHistoryDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IUserChangeHistoryDo
	RightJoin(table schema.Tabler, on ...field.Expr) IUserChangeHistoryDo
	Group(cols ...field.Expr) IUserChangeHistoryDo
	Having(conds ...gen.Condition) IUserChangeHistoryDo
	Limit(limit int) IUserChangeHistoryDo
	Offset(offset int) IUserChangeHistoryDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserChangeHistoryDo
	Unscoped() IUserChangeHistoryDo
	Create(values ...*model.UserChangeHistory) error
	CreateInBatches(values []*model.UserChangeHistory, batchSize int) error
	Save(values ...*model.UserChangeHistory) error
	First() (*model.UserChangeHistory, error)
	Take() (*model.UserChangeHistory, error)
	Last() (*model.UserChangeHistory, error)
	Find() ([]*model.UserChangeHistory, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.UserChangeHistory, err error)
	FindInBatches(result *[]*model.UserChangeHistory, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.UserChangeHistory) (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) IUserChangeHistoryDo
	Assign(attrs ...field.AssignExpr) IUserChangeHistoryDo
	Joins(fields ...field.RelationField) IUserChangeHistoryDo
	Preload(fields ...field.RelationField) IUserChangeHistoryDo
	FirstOrInit() (*model.UserChangeHistory, error)
	FirstOrCreate() (*model.UserChangeHistory, error)
	FindByPage(offset int, limit int) (result []*model.UserChangeHistory, 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) IUserChangeHistoryDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IUserRoleDo

type IUserRoleDo interface {
	gen.SubQuery
	Debug() IUserRoleDo
	WithContext(ctx context.Context) IUserRoleDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IUserRoleDo
	WriteDB() IUserRoleDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IUserRoleDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IUserRoleDo
	Not(conds ...gen.Condition) IUserRoleDo
	Or(conds ...gen.Condition) IUserRoleDo
	Select(conds ...field.Expr) IUserRoleDo
	Where(conds ...gen.Condition) IUserRoleDo
	Order(conds ...field.Expr) IUserRoleDo
	Distinct(cols ...field.Expr) IUserRoleDo
	Omit(cols ...field.Expr) IUserRoleDo
	Join(table schema.Tabler, on ...field.Expr) IUserRoleDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IUserRoleDo
	RightJoin(table schema.Tabler, on ...field.Expr) IUserRoleDo
	Group(cols ...field.Expr) IUserRoleDo
	Having(conds ...gen.Condition) IUserRoleDo
	Limit(limit int) IUserRoleDo
	Offset(offset int) IUserRoleDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserRoleDo
	Unscoped() IUserRoleDo
	Create(values ...*model.UserRole) error
	CreateInBatches(values []*model.UserRole, batchSize int) error
	Save(values ...*model.UserRole) error
	First() (*model.UserRole, error)
	Take() (*model.UserRole, error)
	Last() (*model.UserRole, error)
	Find() ([]*model.UserRole, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.UserRole, err error)
	FindInBatches(result *[]*model.UserRole, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.UserRole) (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) IUserRoleDo
	Assign(attrs ...field.AssignExpr) IUserRoleDo
	Joins(fields ...field.RelationField) IUserRoleDo
	Preload(fields ...field.RelationField) IUserRoleDo
	FirstOrInit() (*model.UserRole, error)
	FirstOrCreate() (*model.UserRole, error)
	FindByPage(offset int, limit int) (result []*model.UserRole, 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) IUserRoleDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type Query

type Query struct {
	Attendance                attendance
	AttendanceResult          attendanceResult
	AuthGroup                 authGroup
	AuthGroupPermissions      authGroupPermissions
	AuthPermission            authPermission
	AuthUser                  authUser
	AuthUserGroups            authUserGroups
	AuthUserUserPermissions   authUserUserPermissions
	CollectDoc                collectDoc
	CollectDocDemo            collectDocDemo
	CollectDocImportant       collectDocImportant
	CollectDocParams          collectDocParams
	CollectDocResult          collectDocResult
	CollectEvent              collectEvent
	ConfigDetail              configDetail
	ConfigDetailChangeHistory configDetailChangeHistory
	ConfigGroup               configGroup
	DjangoAdminLog            djangoAdminLog
	DjangoContentType         djangoContentType
	DjangoMigrations          djangoMigrations
	DjangoSession             djangoSession
	DocGroup                  docGroup
	LdapGroup                 ldapGroup
	Project                   project
	ReportGitcommitinfo       reportGitcommitinfo
	ReportGituserFix          reportGituserFix
	Role                      role
	RoleLdapGroup             roleLdapGroup
	RoleMenu                  roleMenu
	SysCode                   sysCode
	SysMenu                   sysMenu
	SysParam                  sysParam
	TemplateEventLog          templateEventLog
	UserAccount               userAccount
	UserChangeHistory         userChangeHistory
	UserRole                  userRole
	// contains filtered or unexported fields
}

func Use

func Use(db *gorm.DB, opts ...gen.DOOption) *Query

func (*Query) Available

func (q *Query) Available() bool

func (*Query) Begin

func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx

func (*Query) ReadDB

func (q *Query) ReadDB() *Query

func (*Query) ReplaceDB

func (q *Query) ReplaceDB(db *gorm.DB) *Query

func (*Query) Transaction

func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error

func (*Query) WithContext

func (q *Query) WithContext(ctx context.Context) *queryCtx

func (*Query) WriteDB

func (q *Query) WriteDB() *Query

type QueryTx

type QueryTx struct{ *Query }

func (*QueryTx) Commit

func (q *QueryTx) Commit() error

func (*QueryTx) Rollback

func (q *QueryTx) Rollback() error

func (*QueryTx) RollbackTo

func (q *QueryTx) RollbackTo(name string) error

func (*QueryTx) SavePoint

func (q *QueryTx) SavePoint(name string) error