query

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

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

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

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

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

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

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

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

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

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

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

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

type Query struct {
	OmsCartItem          omsCartItem
	OmsCompanyAddress    omsCompanyAddress
	OmsOrderDelivery     omsOrderDelivery
	OmsOrderItem         omsOrderItem
	OmsOrderMain         omsOrderMain
	OmsOrderOperationLog omsOrderOperationLog
	OmsOrderPayment      omsOrderPayment
	OmsOrderPromotion    omsOrderPromotion
	OmsOrderReturn       omsOrderReturn
	OmsOrderReturnItem   omsOrderReturnItem
	OmsOrderReturnReason omsOrderReturnReason
	OmsOrderSetting      omsOrderSetting
	// contains filtered or unexported fields
}

type QueryTx struct {
	*Query
	Error error
}