query

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type Query struct {
	PmsAlbum                            pmsAlbum
	PmsAlbumPic                         pmsAlbumPic
	PmsBrand                            pmsBrand
	PmsComment                          pmsComment
	PmsCommentReplay                    pmsCommentReplay
	PmsFeightTemplate                   pmsFeightTemplate
	PmsMemberPrice                      pmsMemberPrice
	PmsProduct                          pmsProduct
	PmsProductAttribute                 pmsProductAttribute
	PmsProductAttributeCategory         pmsProductAttributeCategory
	PmsProductAttributeValue            pmsProductAttributeValue
	PmsProductCategory                  pmsProductCategory
	PmsProductCategoryAttributeRelation pmsProductCategoryAttributeRelation
	PmsProductCollect                   pmsProductCollect
	PmsProductFullReduction             pmsProductFullReduction
	PmsProductLadder                    pmsProductLadder
	PmsProductOperateLog                pmsProductOperateLog
	PmsProductVertifyRecord             pmsProductVertifyRecord
	PmsSkuStock                         pmsSkuStock
	// contains filtered or unexported fields
}

type QueryTx struct {
	*Query
	Error error
}