models_generated

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type IAccountDeleteTokenDo
• type IBillingBypassOrganizationDo
• type IChatDo
• type ICustomerDo
• type IDiggerBatchDo
• type IDiggerJobDo
• type IDiggerJobParentLinkDo
• type IDiggerJobSummaryDo
• type IDiggerJobTokenDo
• type IDiggerLockDo
• type IDiggerRunDo
• type IDiggerRunQueueItemDo
• type IDiggerRunStageDo
• type IEnvVarDo
• type IGithubAppDo
• type IGithubAppInstallationDo
• type IGithubAppInstallationLinkDo
• type IInternalBlogAuthorPostDo
• type IInternalBlogAuthorProfileDo
• type IInternalBlogPostDo
• type IInternalBlogPostTagDo
• type IInternalBlogPostTagsRelationshipDo
• type IInternalChangelogDo
• type IInternalFeedbackCommentDo
• type IInternalFeedbackThreadDo
• type IOrganizationCreditDo
• type IOrganizationDo
• type IOrganizationJoinInvitationDo
• type IOrganizationMemberDo
• type IOrganizationsPrivateInfoDo
• type IPriceDo
• type IProductDo
• type IProjectCommentDo
• type IProjectDo
• type IProjectTfvarDo
• type IRepoDo
• type ISubscriptionDo
• type ITeamDo
• type ITeamMemberDo
• type IUserAPIKeyDo
• type IUserM2mApplicationDo
• type IUserNotificationDo
• type IUserOnboardingDo
• type IUserPrivateInfoDo
• type IUserProfileDo
• 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)
	AccountDeleteToken               *accountDeleteToken
	BillingBypassOrganization        *billingBypassOrganization
	Chat                             *chat
	Customer                         *customer
	DiggerBatch                      *diggerBatch
	DiggerJob                        *diggerJob
	DiggerJobParentLink              *diggerJobParentLink
	DiggerJobSummary                 *diggerJobSummary
	DiggerJobToken                   *diggerJobToken
	DiggerLock                       *diggerLock
	DiggerRun                        *diggerRun
	DiggerRunQueueItem               *diggerRunQueueItem
	DiggerRunStage                   *diggerRunStage
	EnvVar                           *envVar
	GithubApp                        *githubApp
	GithubAppInstallation            *githubAppInstallation
	GithubAppInstallationLink        *githubAppInstallationLink
	InternalBlogAuthorPost           *internalBlogAuthorPost
	InternalBlogAuthorProfile        *internalBlogAuthorProfile
	InternalBlogPost                 *internalBlogPost
	InternalBlogPostTag              *internalBlogPostTag
	InternalBlogPostTagsRelationship *internalBlogPostTagsRelationship
	InternalChangelog                *internalChangelog
	InternalFeedbackComment          *internalFeedbackComment
	InternalFeedbackThread           *internalFeedbackThread
	Organization                     *organization
	OrganizationCredit               *organizationCredit
	OrganizationJoinInvitation       *organizationJoinInvitation
	OrganizationMember               *organizationMember
	OrganizationsPrivateInfo         *organizationsPrivateInfo
	Price                            *price
	Product                          *product
	Project                          *project
	ProjectComment                   *projectComment
	ProjectTfvar                     *projectTfvar
	Repo                             *repo
	Subscription                     *subscription
	Team                             *team
	TeamMember                       *teamMember
	UserAPIKey                       *userAPIKey
	UserM2mApplication               *userM2mApplication
	UserNotification                 *userNotification
	UserOnboarding                   *userOnboarding
	UserPrivateInfo                  *userPrivateInfo
	UserProfile                      *userProfile
	UserRole                         *userRole
)

Functions

func SetDefault

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

Types

type IAccountDeleteTokenDo

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

type IBillingBypassOrganizationDo

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

type IChatDo

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

type ICustomerDo

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

type IDiggerBatchDo

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

type IDiggerJobDo

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

type IDiggerJobParentLinkDo

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

type IDiggerJobSummaryDo

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

type IDiggerJobTokenDo

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

type IDiggerLockDo

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

type IDiggerRunDo

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

type IDiggerRunQueueItemDo

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

type IDiggerRunStageDo

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

type IEnvVarDo

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

type IGithubAppDo

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

type IGithubAppInstallationDo

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

type IGithubAppInstallationLinkDo

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

type IInternalBlogAuthorPostDo

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

type IInternalBlogAuthorProfileDo

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

type IInternalBlogPostDo

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

type IInternalBlogPostTagDo

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

type IInternalBlogPostTagsRelationshipDo

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

type IInternalChangelogDo

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

type IInternalFeedbackCommentDo

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

type IInternalFeedbackThreadDo

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

type IOrganizationCreditDo

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

type IOrganizationDo

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

type IOrganizationJoinInvitationDo

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

type IOrganizationMemberDo

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

type IOrganizationsPrivateInfoDo

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

type IPriceDo

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

type IProductDo

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

type IProjectCommentDo

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

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

type IRepoDo

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

type ISubscriptionDo

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

type ITeamDo

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

type ITeamMemberDo

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

type IUserAPIKeyDo

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

type IUserM2mApplicationDo

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

type IUserNotificationDo

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

type IUserOnboardingDo

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

type IUserPrivateInfoDo

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

type IUserProfileDo

type IUserProfileDo interface {
	gen.SubQuery
	Debug() IUserProfileDo
	WithContext(ctx context.Context) IUserProfileDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IUserProfileDo
	WriteDB() IUserProfileDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IUserProfileDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IUserProfileDo
	Not(conds ...gen.Condition) IUserProfileDo
	Or(conds ...gen.Condition) IUserProfileDo
	Select(conds ...field.Expr) IUserProfileDo
	Where(conds ...gen.Condition) IUserProfileDo
	Order(conds ...field.Expr) IUserProfileDo
	Distinct(cols ...field.Expr) IUserProfileDo
	Omit(cols ...field.Expr) IUserProfileDo
	Join(table schema.Tabler, on ...field.Expr) IUserProfileDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IUserProfileDo
	RightJoin(table schema.Tabler, on ...field.Expr) IUserProfileDo
	Group(cols ...field.Expr) IUserProfileDo
	Having(conds ...gen.Condition) IUserProfileDo
	Limit(limit int) IUserProfileDo
	Offset(offset int) IUserProfileDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserProfileDo
	Unscoped() IUserProfileDo
	Create(values ...*model.UserProfile) error
	CreateInBatches(values []*model.UserProfile, batchSize int) error
	Save(values ...*model.UserProfile) error
	First() (*model.UserProfile, error)
	Take() (*model.UserProfile, error)
	Last() (*model.UserProfile, error)
	Find() ([]*model.UserProfile, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.UserProfile, err error)
	FindInBatches(result *[]*model.UserProfile, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.UserProfile) (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) IUserProfileDo
	Assign(attrs ...field.AssignExpr) IUserProfileDo
	Joins(fields ...field.RelationField) IUserProfileDo
	Preload(fields ...field.RelationField) IUserProfileDo
	FirstOrInit() (*model.UserProfile, error)
	FirstOrCreate() (*model.UserProfile, error)
	FindByPage(offset int, limit int) (result []*model.UserProfile, 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) IUserProfileDo
	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 {
	AccountDeleteToken               accountDeleteToken
	BillingBypassOrganization        billingBypassOrganization
	Chat                             chat
	Customer                         customer
	DiggerBatch                      diggerBatch
	DiggerJob                        diggerJob
	DiggerJobParentLink              diggerJobParentLink
	DiggerJobSummary                 diggerJobSummary
	DiggerJobToken                   diggerJobToken
	DiggerLock                       diggerLock
	DiggerRun                        diggerRun
	DiggerRunQueueItem               diggerRunQueueItem
	DiggerRunStage                   diggerRunStage
	EnvVar                           envVar
	GithubApp                        githubApp
	GithubAppInstallation            githubAppInstallation
	GithubAppInstallationLink        githubAppInstallationLink
	InternalBlogAuthorPost           internalBlogAuthorPost
	InternalBlogAuthorProfile        internalBlogAuthorProfile
	InternalBlogPost                 internalBlogPost
	InternalBlogPostTag              internalBlogPostTag
	InternalBlogPostTagsRelationship internalBlogPostTagsRelationship
	InternalChangelog                internalChangelog
	InternalFeedbackComment          internalFeedbackComment
	InternalFeedbackThread           internalFeedbackThread
	Organization                     organization
	OrganizationCredit               organizationCredit
	OrganizationJoinInvitation       organizationJoinInvitation
	OrganizationMember               organizationMember
	OrganizationsPrivateInfo         organizationsPrivateInfo
	Price                            price
	Product                          product
	Project                          project
	ProjectComment                   projectComment
	ProjectTfvar                     projectTfvar
	Repo                             repo
	Subscription                     subscription
	Team                             team
	TeamMember                       teamMember
	UserAPIKey                       userAPIKey
	UserM2mApplication               userM2mApplication
	UserNotification                 userNotification
	UserOnboarding                   userOnboarding
	UserPrivateInfo                  userPrivateInfo
	UserProfile                      userProfile
	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
	Error error
}

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