diff --git a/bj_power_mes/internal/handler/production/dock.go b/bj_power_mes/internal/handler/production/dock.go
index ffd6204..f03836e 100644
--- a/bj_power_mes/internal/handler/production/dock.go
+++ b/bj_power_mes/internal/handler/production/dock.go
@@ -44,7 +44,7 @@ func dockRowOf(d *ent.Dock) dockRow {
 // ListDocksHandler GET /docks 接驳台全量列表（工位/排产/AGV 下拉真源，读本地 dock 表）。
 func ListDocksHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		list, err := svcCtx.EntClient.Dock.Query().Order(ent.Asc("dockCode")).All(r.Context())
+		list, err := svcCtx.EntClient.Dock.Query().Order(dock.ByDockCode()).All(r.Context())
 		if err != nil {
 			httpx.Fail(w, 3113, "查询接驳台失败："+err.Error())
 			return
@@ -107,7 +107,7 @@ func ListDocksMaintHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 // （WMS 出库目标工位下拉 / AGV 页接驳台列表；dock 真源已迁 MES）。X-API-TOKEN 保护。
 func ListDocksInternalHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
-		list, err := svcCtx.EntClient.Dock.Query().Order(ent.Asc("dockCode")).All(r.Context())
+		list, err := svcCtx.EntClient.Dock.Query().Order(dock.ByDockCode()).All(r.Context())
 		if err != nil {
 			httpx.Fail(w, 3113, "查询接驳台失败："+err.Error())
 			return
diff --git a/bj_power_wms/agvtask/agvtask.go b/bj_power_wms/agvtask/agvtask.go
new file mode 100644
index 0000000..4a5ef5b
--- /dev/null
+++ b/bj_power_wms/agvtask/agvtask.go
@@ -0,0 +1,178 @@
+// Code generated by ent, DO NOT EDIT.
+
+package agvtask
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the agvtask type in the database.
+	Label = "agv_task"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldTaskNo holds the string denoting the task_no field in the database.
+	FieldTaskNo = "task_no"
+	// FieldHikTaskCode holds the string denoting the hik_task_code field in the database.
+	FieldHikTaskCode = "hik_task_code"
+	// FieldSourceDock holds the string denoting the source_dock field in the database.
+	FieldSourceDock = "source_dock"
+	// FieldTargetDock holds the string denoting the target_dock field in the database.
+	FieldTargetDock = "target_dock"
+	// FieldMaterialsJSON holds the string denoting the materials_json field in the database.
+	FieldMaterialsJSON = "materials_json"
+	// FieldRelatedOutboundNo holds the string denoting the related_outbound_no field in the database.
+	FieldRelatedOutboundNo = "related_outbound_no"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldOperator holds the string denoting the operator field in the database.
+	FieldOperator = "operator"
+	// FieldDispatchedAt holds the string denoting the dispatched_at field in the database.
+	FieldDispatchedAt = "dispatched_at"
+	// FieldArrivedAt holds the string denoting the arrived_at field in the database.
+	FieldArrivedAt = "arrived_at"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// Table holds the table name of the agvtask in the database.
+	Table = "agv_tasks"
+)
+
+// Columns holds all SQL columns for agvtask fields.
+var Columns = []string{
+	FieldID,
+	FieldTaskNo,
+	FieldHikTaskCode,
+	FieldSourceDock,
+	FieldTargetDock,
+	FieldMaterialsJSON,
+	FieldRelatedOutboundNo,
+	FieldStatus,
+	FieldOperator,
+	FieldDispatchedAt,
+	FieldArrivedAt,
+	FieldRemark,
+	FieldCreatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// TaskNoValidator is a validator for the "task_no" field. It is called by the builders before save.
+	TaskNoValidator func(string) error
+	// DefaultHikTaskCode holds the default value on creation for the "hik_task_code" field.
+	DefaultHikTaskCode string
+	// HikTaskCodeValidator is a validator for the "hik_task_code" field. It is called by the builders before save.
+	HikTaskCodeValidator func(string) error
+	// DefaultSourceDock holds the default value on creation for the "source_dock" field.
+	DefaultSourceDock string
+	// SourceDockValidator is a validator for the "source_dock" field. It is called by the builders before save.
+	SourceDockValidator func(string) error
+	// DefaultTargetDock holds the default value on creation for the "target_dock" field.
+	DefaultTargetDock string
+	// TargetDockValidator is a validator for the "target_dock" field. It is called by the builders before save.
+	TargetDockValidator func(string) error
+	// DefaultMaterialsJSON holds the default value on creation for the "materials_json" field.
+	DefaultMaterialsJSON string
+	// MaterialsJSONValidator is a validator for the "materials_json" field. It is called by the builders before save.
+	MaterialsJSONValidator func(string) error
+	// DefaultRelatedOutboundNo holds the default value on creation for the "related_outbound_no" field.
+	DefaultRelatedOutboundNo string
+	// RelatedOutboundNoValidator is a validator for the "related_outbound_no" field. It is called by the builders before save.
+	RelatedOutboundNoValidator func(string) error
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// StatusValidator is a validator for the "status" field. It is called by the builders before save.
+	StatusValidator func(string) error
+	// DefaultOperator holds the default value on creation for the "operator" field.
+	DefaultOperator string
+	// OperatorValidator is a validator for the "operator" field. It is called by the builders before save.
+	OperatorValidator func(string) error
+	// DefaultDispatchedAt holds the default value on creation for the "dispatched_at" field.
+	DefaultDispatchedAt int64
+	// DefaultArrivedAt holds the default value on creation for the "arrived_at" field.
+	DefaultArrivedAt int64
+	// DefaultRemark holds the default value on creation for the "remark" field.
+	DefaultRemark string
+	// RemarkValidator is a validator for the "remark" field. It is called by the builders before save.
+	RemarkValidator func(string) error
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the AgvTask queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByTaskNo orders the results by the task_no field.
+func ByTaskNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTaskNo, opts...).ToFunc()
+}
+
+// ByHikTaskCode orders the results by the hik_task_code field.
+func ByHikTaskCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldHikTaskCode, opts...).ToFunc()
+}
+
+// BySourceDock orders the results by the source_dock field.
+func BySourceDock(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSourceDock, opts...).ToFunc()
+}
+
+// ByTargetDock orders the results by the target_dock field.
+func ByTargetDock(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetDock, opts...).ToFunc()
+}
+
+// ByMaterialsJSON orders the results by the materials_json field.
+func ByMaterialsJSON(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialsJSON, opts...).ToFunc()
+}
+
+// ByRelatedOutboundNo orders the results by the related_outbound_no field.
+func ByRelatedOutboundNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRelatedOutboundNo, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByOperator orders the results by the operator field.
+func ByOperator(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOperator, opts...).ToFunc()
+}
+
+// ByDispatchedAt orders the results by the dispatched_at field.
+func ByDispatchedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDispatchedAt, opts...).ToFunc()
+}
+
+// ByArrivedAt orders the results by the arrived_at field.
+func ByArrivedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldArrivedAt, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/agvtask/where.go b/bj_power_wms/agvtask/where.go
new file mode 100644
index 0000000..34b351f
--- /dev/null
+++ b/bj_power_wms/agvtask/where.go
@@ -0,0 +1,854 @@
+// Code generated by ent, DO NOT EDIT.
+
+package agvtask
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldID, id))
+}
+
+// TaskNo applies equality check predicate on the "task_no" field. It's identical to TaskNoEQ.
+func TaskNo(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldTaskNo, v))
+}
+
+// HikTaskCode applies equality check predicate on the "hik_task_code" field. It's identical to HikTaskCodeEQ.
+func HikTaskCode(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldHikTaskCode, v))
+}
+
+// SourceDock applies equality check predicate on the "source_dock" field. It's identical to SourceDockEQ.
+func SourceDock(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldSourceDock, v))
+}
+
+// TargetDock applies equality check predicate on the "target_dock" field. It's identical to TargetDockEQ.
+func TargetDock(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldTargetDock, v))
+}
+
+// MaterialsJSON applies equality check predicate on the "materials_json" field. It's identical to MaterialsJSONEQ.
+func MaterialsJSON(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldMaterialsJSON, v))
+}
+
+// RelatedOutboundNo applies equality check predicate on the "related_outbound_no" field. It's identical to RelatedOutboundNoEQ.
+func RelatedOutboundNo(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldRelatedOutboundNo, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldStatus, v))
+}
+
+// Operator applies equality check predicate on the "operator" field. It's identical to OperatorEQ.
+func Operator(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldOperator, v))
+}
+
+// DispatchedAt applies equality check predicate on the "dispatched_at" field. It's identical to DispatchedAtEQ.
+func DispatchedAt(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldDispatchedAt, v))
+}
+
+// ArrivedAt applies equality check predicate on the "arrived_at" field. It's identical to ArrivedAtEQ.
+func ArrivedAt(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldArrivedAt, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldRemark, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// TaskNoEQ applies the EQ predicate on the "task_no" field.
+func TaskNoEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldTaskNo, v))
+}
+
+// TaskNoNEQ applies the NEQ predicate on the "task_no" field.
+func TaskNoNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldTaskNo, v))
+}
+
+// TaskNoIn applies the In predicate on the "task_no" field.
+func TaskNoIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldTaskNo, vs...))
+}
+
+// TaskNoNotIn applies the NotIn predicate on the "task_no" field.
+func TaskNoNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldTaskNo, vs...))
+}
+
+// TaskNoGT applies the GT predicate on the "task_no" field.
+func TaskNoGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldTaskNo, v))
+}
+
+// TaskNoGTE applies the GTE predicate on the "task_no" field.
+func TaskNoGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldTaskNo, v))
+}
+
+// TaskNoLT applies the LT predicate on the "task_no" field.
+func TaskNoLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldTaskNo, v))
+}
+
+// TaskNoLTE applies the LTE predicate on the "task_no" field.
+func TaskNoLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldTaskNo, v))
+}
+
+// TaskNoContains applies the Contains predicate on the "task_no" field.
+func TaskNoContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldTaskNo, v))
+}
+
+// TaskNoHasPrefix applies the HasPrefix predicate on the "task_no" field.
+func TaskNoHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldTaskNo, v))
+}
+
+// TaskNoHasSuffix applies the HasSuffix predicate on the "task_no" field.
+func TaskNoHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldTaskNo, v))
+}
+
+// TaskNoEqualFold applies the EqualFold predicate on the "task_no" field.
+func TaskNoEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldTaskNo, v))
+}
+
+// TaskNoContainsFold applies the ContainsFold predicate on the "task_no" field.
+func TaskNoContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldTaskNo, v))
+}
+
+// HikTaskCodeEQ applies the EQ predicate on the "hik_task_code" field.
+func HikTaskCodeEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeNEQ applies the NEQ predicate on the "hik_task_code" field.
+func HikTaskCodeNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeIn applies the In predicate on the "hik_task_code" field.
+func HikTaskCodeIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldHikTaskCode, vs...))
+}
+
+// HikTaskCodeNotIn applies the NotIn predicate on the "hik_task_code" field.
+func HikTaskCodeNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldHikTaskCode, vs...))
+}
+
+// HikTaskCodeGT applies the GT predicate on the "hik_task_code" field.
+func HikTaskCodeGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeGTE applies the GTE predicate on the "hik_task_code" field.
+func HikTaskCodeGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeLT applies the LT predicate on the "hik_task_code" field.
+func HikTaskCodeLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeLTE applies the LTE predicate on the "hik_task_code" field.
+func HikTaskCodeLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeContains applies the Contains predicate on the "hik_task_code" field.
+func HikTaskCodeContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeHasPrefix applies the HasPrefix predicate on the "hik_task_code" field.
+func HikTaskCodeHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeHasSuffix applies the HasSuffix predicate on the "hik_task_code" field.
+func HikTaskCodeHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeEqualFold applies the EqualFold predicate on the "hik_task_code" field.
+func HikTaskCodeEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldHikTaskCode, v))
+}
+
+// HikTaskCodeContainsFold applies the ContainsFold predicate on the "hik_task_code" field.
+func HikTaskCodeContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldHikTaskCode, v))
+}
+
+// SourceDockEQ applies the EQ predicate on the "source_dock" field.
+func SourceDockEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldSourceDock, v))
+}
+
+// SourceDockNEQ applies the NEQ predicate on the "source_dock" field.
+func SourceDockNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldSourceDock, v))
+}
+
+// SourceDockIn applies the In predicate on the "source_dock" field.
+func SourceDockIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldSourceDock, vs...))
+}
+
+// SourceDockNotIn applies the NotIn predicate on the "source_dock" field.
+func SourceDockNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldSourceDock, vs...))
+}
+
+// SourceDockGT applies the GT predicate on the "source_dock" field.
+func SourceDockGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldSourceDock, v))
+}
+
+// SourceDockGTE applies the GTE predicate on the "source_dock" field.
+func SourceDockGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldSourceDock, v))
+}
+
+// SourceDockLT applies the LT predicate on the "source_dock" field.
+func SourceDockLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldSourceDock, v))
+}
+
+// SourceDockLTE applies the LTE predicate on the "source_dock" field.
+func SourceDockLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldSourceDock, v))
+}
+
+// SourceDockContains applies the Contains predicate on the "source_dock" field.
+func SourceDockContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldSourceDock, v))
+}
+
+// SourceDockHasPrefix applies the HasPrefix predicate on the "source_dock" field.
+func SourceDockHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldSourceDock, v))
+}
+
+// SourceDockHasSuffix applies the HasSuffix predicate on the "source_dock" field.
+func SourceDockHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldSourceDock, v))
+}
+
+// SourceDockEqualFold applies the EqualFold predicate on the "source_dock" field.
+func SourceDockEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldSourceDock, v))
+}
+
+// SourceDockContainsFold applies the ContainsFold predicate on the "source_dock" field.
+func SourceDockContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldSourceDock, v))
+}
+
+// TargetDockEQ applies the EQ predicate on the "target_dock" field.
+func TargetDockEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldTargetDock, v))
+}
+
+// TargetDockNEQ applies the NEQ predicate on the "target_dock" field.
+func TargetDockNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldTargetDock, v))
+}
+
+// TargetDockIn applies the In predicate on the "target_dock" field.
+func TargetDockIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldTargetDock, vs...))
+}
+
+// TargetDockNotIn applies the NotIn predicate on the "target_dock" field.
+func TargetDockNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldTargetDock, vs...))
+}
+
+// TargetDockGT applies the GT predicate on the "target_dock" field.
+func TargetDockGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldTargetDock, v))
+}
+
+// TargetDockGTE applies the GTE predicate on the "target_dock" field.
+func TargetDockGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldTargetDock, v))
+}
+
+// TargetDockLT applies the LT predicate on the "target_dock" field.
+func TargetDockLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldTargetDock, v))
+}
+
+// TargetDockLTE applies the LTE predicate on the "target_dock" field.
+func TargetDockLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldTargetDock, v))
+}
+
+// TargetDockContains applies the Contains predicate on the "target_dock" field.
+func TargetDockContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldTargetDock, v))
+}
+
+// TargetDockHasPrefix applies the HasPrefix predicate on the "target_dock" field.
+func TargetDockHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldTargetDock, v))
+}
+
+// TargetDockHasSuffix applies the HasSuffix predicate on the "target_dock" field.
+func TargetDockHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldTargetDock, v))
+}
+
+// TargetDockEqualFold applies the EqualFold predicate on the "target_dock" field.
+func TargetDockEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldTargetDock, v))
+}
+
+// TargetDockContainsFold applies the ContainsFold predicate on the "target_dock" field.
+func TargetDockContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldTargetDock, v))
+}
+
+// MaterialsJSONEQ applies the EQ predicate on the "materials_json" field.
+func MaterialsJSONEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONNEQ applies the NEQ predicate on the "materials_json" field.
+func MaterialsJSONNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONIn applies the In predicate on the "materials_json" field.
+func MaterialsJSONIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldMaterialsJSON, vs...))
+}
+
+// MaterialsJSONNotIn applies the NotIn predicate on the "materials_json" field.
+func MaterialsJSONNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldMaterialsJSON, vs...))
+}
+
+// MaterialsJSONGT applies the GT predicate on the "materials_json" field.
+func MaterialsJSONGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONGTE applies the GTE predicate on the "materials_json" field.
+func MaterialsJSONGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONLT applies the LT predicate on the "materials_json" field.
+func MaterialsJSONLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONLTE applies the LTE predicate on the "materials_json" field.
+func MaterialsJSONLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONContains applies the Contains predicate on the "materials_json" field.
+func MaterialsJSONContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONHasPrefix applies the HasPrefix predicate on the "materials_json" field.
+func MaterialsJSONHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONHasSuffix applies the HasSuffix predicate on the "materials_json" field.
+func MaterialsJSONHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONEqualFold applies the EqualFold predicate on the "materials_json" field.
+func MaterialsJSONEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldMaterialsJSON, v))
+}
+
+// MaterialsJSONContainsFold applies the ContainsFold predicate on the "materials_json" field.
+func MaterialsJSONContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldMaterialsJSON, v))
+}
+
+// RelatedOutboundNoEQ applies the EQ predicate on the "related_outbound_no" field.
+func RelatedOutboundNoEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoNEQ applies the NEQ predicate on the "related_outbound_no" field.
+func RelatedOutboundNoNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoIn applies the In predicate on the "related_outbound_no" field.
+func RelatedOutboundNoIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldRelatedOutboundNo, vs...))
+}
+
+// RelatedOutboundNoNotIn applies the NotIn predicate on the "related_outbound_no" field.
+func RelatedOutboundNoNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldRelatedOutboundNo, vs...))
+}
+
+// RelatedOutboundNoGT applies the GT predicate on the "related_outbound_no" field.
+func RelatedOutboundNoGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoGTE applies the GTE predicate on the "related_outbound_no" field.
+func RelatedOutboundNoGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoLT applies the LT predicate on the "related_outbound_no" field.
+func RelatedOutboundNoLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoLTE applies the LTE predicate on the "related_outbound_no" field.
+func RelatedOutboundNoLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoContains applies the Contains predicate on the "related_outbound_no" field.
+func RelatedOutboundNoContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoHasPrefix applies the HasPrefix predicate on the "related_outbound_no" field.
+func RelatedOutboundNoHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoHasSuffix applies the HasSuffix predicate on the "related_outbound_no" field.
+func RelatedOutboundNoHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoIsNil applies the IsNil predicate on the "related_outbound_no" field.
+func RelatedOutboundNoIsNil() predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIsNull(FieldRelatedOutboundNo))
+}
+
+// RelatedOutboundNoNotNil applies the NotNil predicate on the "related_outbound_no" field.
+func RelatedOutboundNoNotNil() predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotNull(FieldRelatedOutboundNo))
+}
+
+// RelatedOutboundNoEqualFold applies the EqualFold predicate on the "related_outbound_no" field.
+func RelatedOutboundNoEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldRelatedOutboundNo, v))
+}
+
+// RelatedOutboundNoContainsFold applies the ContainsFold predicate on the "related_outbound_no" field.
+func RelatedOutboundNoContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldRelatedOutboundNo, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// OperatorEQ applies the EQ predicate on the "operator" field.
+func OperatorEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldOperator, v))
+}
+
+// OperatorNEQ applies the NEQ predicate on the "operator" field.
+func OperatorNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldOperator, v))
+}
+
+// OperatorIn applies the In predicate on the "operator" field.
+func OperatorIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldOperator, vs...))
+}
+
+// OperatorNotIn applies the NotIn predicate on the "operator" field.
+func OperatorNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldOperator, vs...))
+}
+
+// OperatorGT applies the GT predicate on the "operator" field.
+func OperatorGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldOperator, v))
+}
+
+// OperatorGTE applies the GTE predicate on the "operator" field.
+func OperatorGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldOperator, v))
+}
+
+// OperatorLT applies the LT predicate on the "operator" field.
+func OperatorLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldOperator, v))
+}
+
+// OperatorLTE applies the LTE predicate on the "operator" field.
+func OperatorLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldOperator, v))
+}
+
+// OperatorContains applies the Contains predicate on the "operator" field.
+func OperatorContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldOperator, v))
+}
+
+// OperatorHasPrefix applies the HasPrefix predicate on the "operator" field.
+func OperatorHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldOperator, v))
+}
+
+// OperatorHasSuffix applies the HasSuffix predicate on the "operator" field.
+func OperatorHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldOperator, v))
+}
+
+// OperatorEqualFold applies the EqualFold predicate on the "operator" field.
+func OperatorEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldOperator, v))
+}
+
+// OperatorContainsFold applies the ContainsFold predicate on the "operator" field.
+func OperatorContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldOperator, v))
+}
+
+// DispatchedAtEQ applies the EQ predicate on the "dispatched_at" field.
+func DispatchedAtEQ(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldDispatchedAt, v))
+}
+
+// DispatchedAtNEQ applies the NEQ predicate on the "dispatched_at" field.
+func DispatchedAtNEQ(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldDispatchedAt, v))
+}
+
+// DispatchedAtIn applies the In predicate on the "dispatched_at" field.
+func DispatchedAtIn(vs ...int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldDispatchedAt, vs...))
+}
+
+// DispatchedAtNotIn applies the NotIn predicate on the "dispatched_at" field.
+func DispatchedAtNotIn(vs ...int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldDispatchedAt, vs...))
+}
+
+// DispatchedAtGT applies the GT predicate on the "dispatched_at" field.
+func DispatchedAtGT(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldDispatchedAt, v))
+}
+
+// DispatchedAtGTE applies the GTE predicate on the "dispatched_at" field.
+func DispatchedAtGTE(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldDispatchedAt, v))
+}
+
+// DispatchedAtLT applies the LT predicate on the "dispatched_at" field.
+func DispatchedAtLT(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldDispatchedAt, v))
+}
+
+// DispatchedAtLTE applies the LTE predicate on the "dispatched_at" field.
+func DispatchedAtLTE(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldDispatchedAt, v))
+}
+
+// ArrivedAtEQ applies the EQ predicate on the "arrived_at" field.
+func ArrivedAtEQ(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldArrivedAt, v))
+}
+
+// ArrivedAtNEQ applies the NEQ predicate on the "arrived_at" field.
+func ArrivedAtNEQ(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldArrivedAt, v))
+}
+
+// ArrivedAtIn applies the In predicate on the "arrived_at" field.
+func ArrivedAtIn(vs ...int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldArrivedAt, vs...))
+}
+
+// ArrivedAtNotIn applies the NotIn predicate on the "arrived_at" field.
+func ArrivedAtNotIn(vs ...int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldArrivedAt, vs...))
+}
+
+// ArrivedAtGT applies the GT predicate on the "arrived_at" field.
+func ArrivedAtGT(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldArrivedAt, v))
+}
+
+// ArrivedAtGTE applies the GTE predicate on the "arrived_at" field.
+func ArrivedAtGTE(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldArrivedAt, v))
+}
+
+// ArrivedAtLT applies the LT predicate on the "arrived_at" field.
+func ArrivedAtLT(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldArrivedAt, v))
+}
+
+// ArrivedAtLTE applies the LTE predicate on the "arrived_at" field.
+func ArrivedAtLTE(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldArrivedAt, v))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.AgvTask {
+	return predicate.AgvTask(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.AgvTask) predicate.AgvTask {
+	return predicate.AgvTask(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.AgvTask) predicate.AgvTask {
+	return predicate.AgvTask(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.AgvTask) predicate.AgvTask {
+	return predicate.AgvTask(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/attachment/attachment.go b/bj_power_wms/attachment/attachment.go
new file mode 100644
index 0000000..62a48d1
--- /dev/null
+++ b/bj_power_wms/attachment/attachment.go
@@ -0,0 +1,178 @@
+// Code generated by ent, DO NOT EDIT.
+
+package attachment
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the attachment type in the database.
+	Label = "attachment"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldBizType holds the string denoting the biz_type field in the database.
+	FieldBizType = "biz_type"
+	// FieldBizID holds the string denoting the biz_id field in the database.
+	FieldBizID = "biz_id"
+	// FieldFileName holds the string denoting the file_name field in the database.
+	FieldFileName = "file_name"
+	// FieldFilePath holds the string denoting the file_path field in the database.
+	FieldFilePath = "file_path"
+	// FieldFileType holds the string denoting the file_type field in the database.
+	FieldFileType = "file_type"
+	// FieldFileExt holds the string denoting the file_ext field in the database.
+	FieldFileExt = "file_ext"
+	// FieldFileMd5 holds the string denoting the file_md5 field in the database.
+	FieldFileMd5 = "file_md5"
+	// FieldFileSize holds the string denoting the file_size field in the database.
+	FieldFileSize = "file_size"
+	// FieldMimeType holds the string denoting the mime_type field in the database.
+	FieldMimeType = "mime_type"
+	// FieldUploadedBy holds the string denoting the uploaded_by field in the database.
+	FieldUploadedBy = "uploaded_by"
+	// FieldArchived holds the string denoting the archived field in the database.
+	FieldArchived = "archived"
+	// FieldArchivedAt holds the string denoting the archived_at field in the database.
+	FieldArchivedAt = "archived_at"
+	// FieldDeleted holds the string denoting the deleted field in the database.
+	FieldDeleted = "deleted"
+	// FieldDeletedAt holds the string denoting the deleted_at field in the database.
+	FieldDeletedAt = "deleted_at"
+	// FieldDeletedBy holds the string denoting the deleted_by field in the database.
+	FieldDeletedBy = "deleted_by"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// Table holds the table name of the attachment in the database.
+	Table = "attachments"
+)
+
+// Columns holds all SQL columns for attachment fields.
+var Columns = []string{
+	FieldID,
+	FieldBizType,
+	FieldBizID,
+	FieldFileName,
+	FieldFilePath,
+	FieldFileType,
+	FieldFileExt,
+	FieldFileMd5,
+	FieldFileSize,
+	FieldMimeType,
+	FieldUploadedBy,
+	FieldArchived,
+	FieldArchivedAt,
+	FieldDeleted,
+	FieldDeletedAt,
+	FieldDeletedBy,
+	FieldCreatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultFileSize holds the default value on creation for the "file_size" field.
+	DefaultFileSize int64
+	// DefaultArchived holds the default value on creation for the "archived" field.
+	DefaultArchived bool
+	// DefaultDeleted holds the default value on creation for the "deleted" field.
+	DefaultDeleted bool
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the Attachment queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByBizType orders the results by the biz_type field.
+func ByBizType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBizType, opts...).ToFunc()
+}
+
+// ByBizID orders the results by the biz_id field.
+func ByBizID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBizID, opts...).ToFunc()
+}
+
+// ByFileName orders the results by the file_name field.
+func ByFileName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldFileName, opts...).ToFunc()
+}
+
+// ByFilePath orders the results by the file_path field.
+func ByFilePath(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldFilePath, opts...).ToFunc()
+}
+
+// ByFileType orders the results by the file_type field.
+func ByFileType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldFileType, opts...).ToFunc()
+}
+
+// ByFileExt orders the results by the file_ext field.
+func ByFileExt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldFileExt, opts...).ToFunc()
+}
+
+// ByFileMd5 orders the results by the file_md5 field.
+func ByFileMd5(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldFileMd5, opts...).ToFunc()
+}
+
+// ByFileSize orders the results by the file_size field.
+func ByFileSize(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldFileSize, opts...).ToFunc()
+}
+
+// ByMimeType orders the results by the mime_type field.
+func ByMimeType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMimeType, opts...).ToFunc()
+}
+
+// ByUploadedBy orders the results by the uploaded_by field.
+func ByUploadedBy(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUploadedBy, opts...).ToFunc()
+}
+
+// ByArchived orders the results by the archived field.
+func ByArchived(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldArchived, opts...).ToFunc()
+}
+
+// ByArchivedAt orders the results by the archived_at field.
+func ByArchivedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldArchivedAt, opts...).ToFunc()
+}
+
+// ByDeleted orders the results by the deleted field.
+func ByDeleted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeleted, opts...).ToFunc()
+}
+
+// ByDeletedAt orders the results by the deleted_at field.
+func ByDeletedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeletedAt, opts...).ToFunc()
+}
+
+// ByDeletedBy orders the results by the deleted_by field.
+func ByDeletedBy(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDeletedBy, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/attachment/where.go b/bj_power_wms/attachment/where.go
new file mode 100644
index 0000000..b33c6cf
--- /dev/null
+++ b/bj_power_wms/attachment/where.go
@@ -0,0 +1,1059 @@
+// Code generated by ent, DO NOT EDIT.
+
+package attachment
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldID, id))
+}
+
+// BizType applies equality check predicate on the "biz_type" field. It's identical to BizTypeEQ.
+func BizType(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldBizType, v))
+}
+
+// BizID applies equality check predicate on the "biz_id" field. It's identical to BizIDEQ.
+func BizID(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldBizID, v))
+}
+
+// FileName applies equality check predicate on the "file_name" field. It's identical to FileNameEQ.
+func FileName(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileName, v))
+}
+
+// FilePath applies equality check predicate on the "file_path" field. It's identical to FilePathEQ.
+func FilePath(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFilePath, v))
+}
+
+// FileType applies equality check predicate on the "file_type" field. It's identical to FileTypeEQ.
+func FileType(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileType, v))
+}
+
+// FileExt applies equality check predicate on the "file_ext" field. It's identical to FileExtEQ.
+func FileExt(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileExt, v))
+}
+
+// FileMd5 applies equality check predicate on the "file_md5" field. It's identical to FileMd5EQ.
+func FileMd5(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileMd5, v))
+}
+
+// FileSize applies equality check predicate on the "file_size" field. It's identical to FileSizeEQ.
+func FileSize(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileSize, v))
+}
+
+// MimeType applies equality check predicate on the "mime_type" field. It's identical to MimeTypeEQ.
+func MimeType(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldMimeType, v))
+}
+
+// UploadedBy applies equality check predicate on the "uploaded_by" field. It's identical to UploadedByEQ.
+func UploadedBy(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldUploadedBy, v))
+}
+
+// Archived applies equality check predicate on the "archived" field. It's identical to ArchivedEQ.
+func Archived(v bool) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldArchived, v))
+}
+
+// ArchivedAt applies equality check predicate on the "archived_at" field. It's identical to ArchivedAtEQ.
+func ArchivedAt(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldArchivedAt, v))
+}
+
+// Deleted applies equality check predicate on the "deleted" field. It's identical to DeletedEQ.
+func Deleted(v bool) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldDeleted, v))
+}
+
+// DeletedAt applies equality check predicate on the "deleted_at" field. It's identical to DeletedAtEQ.
+func DeletedAt(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// DeletedBy applies equality check predicate on the "deleted_by" field. It's identical to DeletedByEQ.
+func DeletedBy(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldDeletedBy, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// BizTypeEQ applies the EQ predicate on the "biz_type" field.
+func BizTypeEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldBizType, v))
+}
+
+// BizTypeNEQ applies the NEQ predicate on the "biz_type" field.
+func BizTypeNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldBizType, v))
+}
+
+// BizTypeIn applies the In predicate on the "biz_type" field.
+func BizTypeIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldBizType, vs...))
+}
+
+// BizTypeNotIn applies the NotIn predicate on the "biz_type" field.
+func BizTypeNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldBizType, vs...))
+}
+
+// BizTypeGT applies the GT predicate on the "biz_type" field.
+func BizTypeGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldBizType, v))
+}
+
+// BizTypeGTE applies the GTE predicate on the "biz_type" field.
+func BizTypeGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldBizType, v))
+}
+
+// BizTypeLT applies the LT predicate on the "biz_type" field.
+func BizTypeLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldBizType, v))
+}
+
+// BizTypeLTE applies the LTE predicate on the "biz_type" field.
+func BizTypeLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldBizType, v))
+}
+
+// BizTypeContains applies the Contains predicate on the "biz_type" field.
+func BizTypeContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldBizType, v))
+}
+
+// BizTypeHasPrefix applies the HasPrefix predicate on the "biz_type" field.
+func BizTypeHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldBizType, v))
+}
+
+// BizTypeHasSuffix applies the HasSuffix predicate on the "biz_type" field.
+func BizTypeHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldBizType, v))
+}
+
+// BizTypeEqualFold applies the EqualFold predicate on the "biz_type" field.
+func BizTypeEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldBizType, v))
+}
+
+// BizTypeContainsFold applies the ContainsFold predicate on the "biz_type" field.
+func BizTypeContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldBizType, v))
+}
+
+// BizIDEQ applies the EQ predicate on the "biz_id" field.
+func BizIDEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldBizID, v))
+}
+
+// BizIDNEQ applies the NEQ predicate on the "biz_id" field.
+func BizIDNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldBizID, v))
+}
+
+// BizIDIn applies the In predicate on the "biz_id" field.
+func BizIDIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldBizID, vs...))
+}
+
+// BizIDNotIn applies the NotIn predicate on the "biz_id" field.
+func BizIDNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldBizID, vs...))
+}
+
+// BizIDGT applies the GT predicate on the "biz_id" field.
+func BizIDGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldBizID, v))
+}
+
+// BizIDGTE applies the GTE predicate on the "biz_id" field.
+func BizIDGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldBizID, v))
+}
+
+// BizIDLT applies the LT predicate on the "biz_id" field.
+func BizIDLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldBizID, v))
+}
+
+// BizIDLTE applies the LTE predicate on the "biz_id" field.
+func BizIDLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldBizID, v))
+}
+
+// BizIDContains applies the Contains predicate on the "biz_id" field.
+func BizIDContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldBizID, v))
+}
+
+// BizIDHasPrefix applies the HasPrefix predicate on the "biz_id" field.
+func BizIDHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldBizID, v))
+}
+
+// BizIDHasSuffix applies the HasSuffix predicate on the "biz_id" field.
+func BizIDHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldBizID, v))
+}
+
+// BizIDEqualFold applies the EqualFold predicate on the "biz_id" field.
+func BizIDEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldBizID, v))
+}
+
+// BizIDContainsFold applies the ContainsFold predicate on the "biz_id" field.
+func BizIDContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldBizID, v))
+}
+
+// FileNameEQ applies the EQ predicate on the "file_name" field.
+func FileNameEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileName, v))
+}
+
+// FileNameNEQ applies the NEQ predicate on the "file_name" field.
+func FileNameNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldFileName, v))
+}
+
+// FileNameIn applies the In predicate on the "file_name" field.
+func FileNameIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldFileName, vs...))
+}
+
+// FileNameNotIn applies the NotIn predicate on the "file_name" field.
+func FileNameNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldFileName, vs...))
+}
+
+// FileNameGT applies the GT predicate on the "file_name" field.
+func FileNameGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldFileName, v))
+}
+
+// FileNameGTE applies the GTE predicate on the "file_name" field.
+func FileNameGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldFileName, v))
+}
+
+// FileNameLT applies the LT predicate on the "file_name" field.
+func FileNameLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldFileName, v))
+}
+
+// FileNameLTE applies the LTE predicate on the "file_name" field.
+func FileNameLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldFileName, v))
+}
+
+// FileNameContains applies the Contains predicate on the "file_name" field.
+func FileNameContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldFileName, v))
+}
+
+// FileNameHasPrefix applies the HasPrefix predicate on the "file_name" field.
+func FileNameHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldFileName, v))
+}
+
+// FileNameHasSuffix applies the HasSuffix predicate on the "file_name" field.
+func FileNameHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldFileName, v))
+}
+
+// FileNameEqualFold applies the EqualFold predicate on the "file_name" field.
+func FileNameEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldFileName, v))
+}
+
+// FileNameContainsFold applies the ContainsFold predicate on the "file_name" field.
+func FileNameContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldFileName, v))
+}
+
+// FilePathEQ applies the EQ predicate on the "file_path" field.
+func FilePathEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFilePath, v))
+}
+
+// FilePathNEQ applies the NEQ predicate on the "file_path" field.
+func FilePathNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldFilePath, v))
+}
+
+// FilePathIn applies the In predicate on the "file_path" field.
+func FilePathIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldFilePath, vs...))
+}
+
+// FilePathNotIn applies the NotIn predicate on the "file_path" field.
+func FilePathNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldFilePath, vs...))
+}
+
+// FilePathGT applies the GT predicate on the "file_path" field.
+func FilePathGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldFilePath, v))
+}
+
+// FilePathGTE applies the GTE predicate on the "file_path" field.
+func FilePathGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldFilePath, v))
+}
+
+// FilePathLT applies the LT predicate on the "file_path" field.
+func FilePathLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldFilePath, v))
+}
+
+// FilePathLTE applies the LTE predicate on the "file_path" field.
+func FilePathLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldFilePath, v))
+}
+
+// FilePathContains applies the Contains predicate on the "file_path" field.
+func FilePathContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldFilePath, v))
+}
+
+// FilePathHasPrefix applies the HasPrefix predicate on the "file_path" field.
+func FilePathHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldFilePath, v))
+}
+
+// FilePathHasSuffix applies the HasSuffix predicate on the "file_path" field.
+func FilePathHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldFilePath, v))
+}
+
+// FilePathEqualFold applies the EqualFold predicate on the "file_path" field.
+func FilePathEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldFilePath, v))
+}
+
+// FilePathContainsFold applies the ContainsFold predicate on the "file_path" field.
+func FilePathContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldFilePath, v))
+}
+
+// FileTypeEQ applies the EQ predicate on the "file_type" field.
+func FileTypeEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileType, v))
+}
+
+// FileTypeNEQ applies the NEQ predicate on the "file_type" field.
+func FileTypeNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldFileType, v))
+}
+
+// FileTypeIn applies the In predicate on the "file_type" field.
+func FileTypeIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldFileType, vs...))
+}
+
+// FileTypeNotIn applies the NotIn predicate on the "file_type" field.
+func FileTypeNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldFileType, vs...))
+}
+
+// FileTypeGT applies the GT predicate on the "file_type" field.
+func FileTypeGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldFileType, v))
+}
+
+// FileTypeGTE applies the GTE predicate on the "file_type" field.
+func FileTypeGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldFileType, v))
+}
+
+// FileTypeLT applies the LT predicate on the "file_type" field.
+func FileTypeLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldFileType, v))
+}
+
+// FileTypeLTE applies the LTE predicate on the "file_type" field.
+func FileTypeLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldFileType, v))
+}
+
+// FileTypeContains applies the Contains predicate on the "file_type" field.
+func FileTypeContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldFileType, v))
+}
+
+// FileTypeHasPrefix applies the HasPrefix predicate on the "file_type" field.
+func FileTypeHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldFileType, v))
+}
+
+// FileTypeHasSuffix applies the HasSuffix predicate on the "file_type" field.
+func FileTypeHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldFileType, v))
+}
+
+// FileTypeIsNil applies the IsNil predicate on the "file_type" field.
+func FileTypeIsNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldIsNull(FieldFileType))
+}
+
+// FileTypeNotNil applies the NotNil predicate on the "file_type" field.
+func FileTypeNotNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotNull(FieldFileType))
+}
+
+// FileTypeEqualFold applies the EqualFold predicate on the "file_type" field.
+func FileTypeEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldFileType, v))
+}
+
+// FileTypeContainsFold applies the ContainsFold predicate on the "file_type" field.
+func FileTypeContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldFileType, v))
+}
+
+// FileExtEQ applies the EQ predicate on the "file_ext" field.
+func FileExtEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileExt, v))
+}
+
+// FileExtNEQ applies the NEQ predicate on the "file_ext" field.
+func FileExtNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldFileExt, v))
+}
+
+// FileExtIn applies the In predicate on the "file_ext" field.
+func FileExtIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldFileExt, vs...))
+}
+
+// FileExtNotIn applies the NotIn predicate on the "file_ext" field.
+func FileExtNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldFileExt, vs...))
+}
+
+// FileExtGT applies the GT predicate on the "file_ext" field.
+func FileExtGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldFileExt, v))
+}
+
+// FileExtGTE applies the GTE predicate on the "file_ext" field.
+func FileExtGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldFileExt, v))
+}
+
+// FileExtLT applies the LT predicate on the "file_ext" field.
+func FileExtLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldFileExt, v))
+}
+
+// FileExtLTE applies the LTE predicate on the "file_ext" field.
+func FileExtLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldFileExt, v))
+}
+
+// FileExtContains applies the Contains predicate on the "file_ext" field.
+func FileExtContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldFileExt, v))
+}
+
+// FileExtHasPrefix applies the HasPrefix predicate on the "file_ext" field.
+func FileExtHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldFileExt, v))
+}
+
+// FileExtHasSuffix applies the HasSuffix predicate on the "file_ext" field.
+func FileExtHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldFileExt, v))
+}
+
+// FileExtIsNil applies the IsNil predicate on the "file_ext" field.
+func FileExtIsNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldIsNull(FieldFileExt))
+}
+
+// FileExtNotNil applies the NotNil predicate on the "file_ext" field.
+func FileExtNotNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotNull(FieldFileExt))
+}
+
+// FileExtEqualFold applies the EqualFold predicate on the "file_ext" field.
+func FileExtEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldFileExt, v))
+}
+
+// FileExtContainsFold applies the ContainsFold predicate on the "file_ext" field.
+func FileExtContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldFileExt, v))
+}
+
+// FileMd5EQ applies the EQ predicate on the "file_md5" field.
+func FileMd5EQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileMd5, v))
+}
+
+// FileMd5NEQ applies the NEQ predicate on the "file_md5" field.
+func FileMd5NEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldFileMd5, v))
+}
+
+// FileMd5In applies the In predicate on the "file_md5" field.
+func FileMd5In(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldFileMd5, vs...))
+}
+
+// FileMd5NotIn applies the NotIn predicate on the "file_md5" field.
+func FileMd5NotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldFileMd5, vs...))
+}
+
+// FileMd5GT applies the GT predicate on the "file_md5" field.
+func FileMd5GT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldFileMd5, v))
+}
+
+// FileMd5GTE applies the GTE predicate on the "file_md5" field.
+func FileMd5GTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldFileMd5, v))
+}
+
+// FileMd5LT applies the LT predicate on the "file_md5" field.
+func FileMd5LT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldFileMd5, v))
+}
+
+// FileMd5LTE applies the LTE predicate on the "file_md5" field.
+func FileMd5LTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldFileMd5, v))
+}
+
+// FileMd5Contains applies the Contains predicate on the "file_md5" field.
+func FileMd5Contains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldFileMd5, v))
+}
+
+// FileMd5HasPrefix applies the HasPrefix predicate on the "file_md5" field.
+func FileMd5HasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldFileMd5, v))
+}
+
+// FileMd5HasSuffix applies the HasSuffix predicate on the "file_md5" field.
+func FileMd5HasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldFileMd5, v))
+}
+
+// FileMd5IsNil applies the IsNil predicate on the "file_md5" field.
+func FileMd5IsNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldIsNull(FieldFileMd5))
+}
+
+// FileMd5NotNil applies the NotNil predicate on the "file_md5" field.
+func FileMd5NotNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotNull(FieldFileMd5))
+}
+
+// FileMd5EqualFold applies the EqualFold predicate on the "file_md5" field.
+func FileMd5EqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldFileMd5, v))
+}
+
+// FileMd5ContainsFold applies the ContainsFold predicate on the "file_md5" field.
+func FileMd5ContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldFileMd5, v))
+}
+
+// FileSizeEQ applies the EQ predicate on the "file_size" field.
+func FileSizeEQ(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldFileSize, v))
+}
+
+// FileSizeNEQ applies the NEQ predicate on the "file_size" field.
+func FileSizeNEQ(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldFileSize, v))
+}
+
+// FileSizeIn applies the In predicate on the "file_size" field.
+func FileSizeIn(vs ...int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldFileSize, vs...))
+}
+
+// FileSizeNotIn applies the NotIn predicate on the "file_size" field.
+func FileSizeNotIn(vs ...int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldFileSize, vs...))
+}
+
+// FileSizeGT applies the GT predicate on the "file_size" field.
+func FileSizeGT(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldFileSize, v))
+}
+
+// FileSizeGTE applies the GTE predicate on the "file_size" field.
+func FileSizeGTE(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldFileSize, v))
+}
+
+// FileSizeLT applies the LT predicate on the "file_size" field.
+func FileSizeLT(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldFileSize, v))
+}
+
+// FileSizeLTE applies the LTE predicate on the "file_size" field.
+func FileSizeLTE(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldFileSize, v))
+}
+
+// MimeTypeEQ applies the EQ predicate on the "mime_type" field.
+func MimeTypeEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldMimeType, v))
+}
+
+// MimeTypeNEQ applies the NEQ predicate on the "mime_type" field.
+func MimeTypeNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldMimeType, v))
+}
+
+// MimeTypeIn applies the In predicate on the "mime_type" field.
+func MimeTypeIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldMimeType, vs...))
+}
+
+// MimeTypeNotIn applies the NotIn predicate on the "mime_type" field.
+func MimeTypeNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldMimeType, vs...))
+}
+
+// MimeTypeGT applies the GT predicate on the "mime_type" field.
+func MimeTypeGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldMimeType, v))
+}
+
+// MimeTypeGTE applies the GTE predicate on the "mime_type" field.
+func MimeTypeGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldMimeType, v))
+}
+
+// MimeTypeLT applies the LT predicate on the "mime_type" field.
+func MimeTypeLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldMimeType, v))
+}
+
+// MimeTypeLTE applies the LTE predicate on the "mime_type" field.
+func MimeTypeLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldMimeType, v))
+}
+
+// MimeTypeContains applies the Contains predicate on the "mime_type" field.
+func MimeTypeContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldMimeType, v))
+}
+
+// MimeTypeHasPrefix applies the HasPrefix predicate on the "mime_type" field.
+func MimeTypeHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldMimeType, v))
+}
+
+// MimeTypeHasSuffix applies the HasSuffix predicate on the "mime_type" field.
+func MimeTypeHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldMimeType, v))
+}
+
+// MimeTypeIsNil applies the IsNil predicate on the "mime_type" field.
+func MimeTypeIsNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldIsNull(FieldMimeType))
+}
+
+// MimeTypeNotNil applies the NotNil predicate on the "mime_type" field.
+func MimeTypeNotNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotNull(FieldMimeType))
+}
+
+// MimeTypeEqualFold applies the EqualFold predicate on the "mime_type" field.
+func MimeTypeEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldMimeType, v))
+}
+
+// MimeTypeContainsFold applies the ContainsFold predicate on the "mime_type" field.
+func MimeTypeContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldMimeType, v))
+}
+
+// UploadedByEQ applies the EQ predicate on the "uploaded_by" field.
+func UploadedByEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldUploadedBy, v))
+}
+
+// UploadedByNEQ applies the NEQ predicate on the "uploaded_by" field.
+func UploadedByNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldUploadedBy, v))
+}
+
+// UploadedByIn applies the In predicate on the "uploaded_by" field.
+func UploadedByIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldUploadedBy, vs...))
+}
+
+// UploadedByNotIn applies the NotIn predicate on the "uploaded_by" field.
+func UploadedByNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldUploadedBy, vs...))
+}
+
+// UploadedByGT applies the GT predicate on the "uploaded_by" field.
+func UploadedByGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldUploadedBy, v))
+}
+
+// UploadedByGTE applies the GTE predicate on the "uploaded_by" field.
+func UploadedByGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldUploadedBy, v))
+}
+
+// UploadedByLT applies the LT predicate on the "uploaded_by" field.
+func UploadedByLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldUploadedBy, v))
+}
+
+// UploadedByLTE applies the LTE predicate on the "uploaded_by" field.
+func UploadedByLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldUploadedBy, v))
+}
+
+// UploadedByContains applies the Contains predicate on the "uploaded_by" field.
+func UploadedByContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldUploadedBy, v))
+}
+
+// UploadedByHasPrefix applies the HasPrefix predicate on the "uploaded_by" field.
+func UploadedByHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldUploadedBy, v))
+}
+
+// UploadedByHasSuffix applies the HasSuffix predicate on the "uploaded_by" field.
+func UploadedByHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldUploadedBy, v))
+}
+
+// UploadedByIsNil applies the IsNil predicate on the "uploaded_by" field.
+func UploadedByIsNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldIsNull(FieldUploadedBy))
+}
+
+// UploadedByNotNil applies the NotNil predicate on the "uploaded_by" field.
+func UploadedByNotNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotNull(FieldUploadedBy))
+}
+
+// UploadedByEqualFold applies the EqualFold predicate on the "uploaded_by" field.
+func UploadedByEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldUploadedBy, v))
+}
+
+// UploadedByContainsFold applies the ContainsFold predicate on the "uploaded_by" field.
+func UploadedByContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldUploadedBy, v))
+}
+
+// ArchivedEQ applies the EQ predicate on the "archived" field.
+func ArchivedEQ(v bool) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldArchived, v))
+}
+
+// ArchivedNEQ applies the NEQ predicate on the "archived" field.
+func ArchivedNEQ(v bool) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldArchived, v))
+}
+
+// ArchivedAtEQ applies the EQ predicate on the "archived_at" field.
+func ArchivedAtEQ(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldArchivedAt, v))
+}
+
+// ArchivedAtNEQ applies the NEQ predicate on the "archived_at" field.
+func ArchivedAtNEQ(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldArchivedAt, v))
+}
+
+// ArchivedAtIn applies the In predicate on the "archived_at" field.
+func ArchivedAtIn(vs ...int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldArchivedAt, vs...))
+}
+
+// ArchivedAtNotIn applies the NotIn predicate on the "archived_at" field.
+func ArchivedAtNotIn(vs ...int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldArchivedAt, vs...))
+}
+
+// ArchivedAtGT applies the GT predicate on the "archived_at" field.
+func ArchivedAtGT(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldArchivedAt, v))
+}
+
+// ArchivedAtGTE applies the GTE predicate on the "archived_at" field.
+func ArchivedAtGTE(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldArchivedAt, v))
+}
+
+// ArchivedAtLT applies the LT predicate on the "archived_at" field.
+func ArchivedAtLT(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldArchivedAt, v))
+}
+
+// ArchivedAtLTE applies the LTE predicate on the "archived_at" field.
+func ArchivedAtLTE(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldArchivedAt, v))
+}
+
+// ArchivedAtIsNil applies the IsNil predicate on the "archived_at" field.
+func ArchivedAtIsNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldIsNull(FieldArchivedAt))
+}
+
+// ArchivedAtNotNil applies the NotNil predicate on the "archived_at" field.
+func ArchivedAtNotNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotNull(FieldArchivedAt))
+}
+
+// DeletedEQ applies the EQ predicate on the "deleted" field.
+func DeletedEQ(v bool) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldDeleted, v))
+}
+
+// DeletedNEQ applies the NEQ predicate on the "deleted" field.
+func DeletedNEQ(v bool) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldDeleted, v))
+}
+
+// DeletedAtEQ applies the EQ predicate on the "deleted_at" field.
+func DeletedAtEQ(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtNEQ applies the NEQ predicate on the "deleted_at" field.
+func DeletedAtNEQ(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldDeletedAt, v))
+}
+
+// DeletedAtIn applies the In predicate on the "deleted_at" field.
+func DeletedAtIn(vs ...int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtNotIn applies the NotIn predicate on the "deleted_at" field.
+func DeletedAtNotIn(vs ...int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldDeletedAt, vs...))
+}
+
+// DeletedAtGT applies the GT predicate on the "deleted_at" field.
+func DeletedAtGT(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldDeletedAt, v))
+}
+
+// DeletedAtGTE applies the GTE predicate on the "deleted_at" field.
+func DeletedAtGTE(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldDeletedAt, v))
+}
+
+// DeletedAtLT applies the LT predicate on the "deleted_at" field.
+func DeletedAtLT(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldDeletedAt, v))
+}
+
+// DeletedAtLTE applies the LTE predicate on the "deleted_at" field.
+func DeletedAtLTE(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldDeletedAt, v))
+}
+
+// DeletedAtIsNil applies the IsNil predicate on the "deleted_at" field.
+func DeletedAtIsNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldIsNull(FieldDeletedAt))
+}
+
+// DeletedAtNotNil applies the NotNil predicate on the "deleted_at" field.
+func DeletedAtNotNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotNull(FieldDeletedAt))
+}
+
+// DeletedByEQ applies the EQ predicate on the "deleted_by" field.
+func DeletedByEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldDeletedBy, v))
+}
+
+// DeletedByNEQ applies the NEQ predicate on the "deleted_by" field.
+func DeletedByNEQ(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldDeletedBy, v))
+}
+
+// DeletedByIn applies the In predicate on the "deleted_by" field.
+func DeletedByIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldDeletedBy, vs...))
+}
+
+// DeletedByNotIn applies the NotIn predicate on the "deleted_by" field.
+func DeletedByNotIn(vs ...string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldDeletedBy, vs...))
+}
+
+// DeletedByGT applies the GT predicate on the "deleted_by" field.
+func DeletedByGT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldDeletedBy, v))
+}
+
+// DeletedByGTE applies the GTE predicate on the "deleted_by" field.
+func DeletedByGTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldDeletedBy, v))
+}
+
+// DeletedByLT applies the LT predicate on the "deleted_by" field.
+func DeletedByLT(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldDeletedBy, v))
+}
+
+// DeletedByLTE applies the LTE predicate on the "deleted_by" field.
+func DeletedByLTE(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldDeletedBy, v))
+}
+
+// DeletedByContains applies the Contains predicate on the "deleted_by" field.
+func DeletedByContains(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContains(FieldDeletedBy, v))
+}
+
+// DeletedByHasPrefix applies the HasPrefix predicate on the "deleted_by" field.
+func DeletedByHasPrefix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasPrefix(FieldDeletedBy, v))
+}
+
+// DeletedByHasSuffix applies the HasSuffix predicate on the "deleted_by" field.
+func DeletedByHasSuffix(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldHasSuffix(FieldDeletedBy, v))
+}
+
+// DeletedByIsNil applies the IsNil predicate on the "deleted_by" field.
+func DeletedByIsNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldIsNull(FieldDeletedBy))
+}
+
+// DeletedByNotNil applies the NotNil predicate on the "deleted_by" field.
+func DeletedByNotNil() predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotNull(FieldDeletedBy))
+}
+
+// DeletedByEqualFold applies the EqualFold predicate on the "deleted_by" field.
+func DeletedByEqualFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEqualFold(FieldDeletedBy, v))
+}
+
+// DeletedByContainsFold applies the ContainsFold predicate on the "deleted_by" field.
+func DeletedByContainsFold(v string) predicate.Attachment {
+	return predicate.Attachment(sql.FieldContainsFold(FieldDeletedBy, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.Attachment {
+	return predicate.Attachment(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Attachment) predicate.Attachment {
+	return predicate.Attachment(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Attachment) predicate.Attachment {
+	return predicate.Attachment(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Attachment) predicate.Attachment {
+	return predicate.Attachment(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/ent/migrate/schema.go b/bj_power_wms/ent/migrate/schema.go
index c1cec55..e8ce0be 100644
--- a/bj_power_wms/ent/migrate/schema.go
+++ b/bj_power_wms/ent/migrate/schema.go
@@ -534,6 +534,7 @@ var (
 		{Name: "box_no", Type: field.TypeString, Nullable: true},
 		{Name: "box_sn_list", Type: field.TypeString, Nullable: true},
 		{Name: "contract_no", Type: field.TypeString, Nullable: true},
+		{Name: "inspection_no", Type: field.TypeString, Nullable: true},
 		{Name: "created_at", Type: field.TypeInt64},
 	}
 	// OutboundOrdersTable holds the schema information for the "outbound_orders" table.
@@ -562,6 +563,11 @@ var (
 				Unique:  false,
 				Columns: []*schema.Column{OutboundOrdersColumns[23]},
 			},
+			{
+				Name:    "outboundorder_inspection_no",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundOrdersColumns[26]},
+			},
 		},
 	}
 	// PermissionsColumns holds the columns for the "permissions" table.
diff --git a/bj_power_wms/ent/mutation.go b/bj_power_wms/ent/mutation.go
index bb5ee74..9d14872 100644
--- a/bj_power_wms/ent/mutation.go
+++ b/bj_power_wms/ent/mutation.go
@@ -15215,6 +15215,7 @@ type OutboundOrderMutation struct {
 	box_no            *string
 	box_sn_list       *string
 	contract_no       *string
+	inspection_no     *string
 	created_at        *int64
 	addcreated_at     *int64
 	clearedFields     map[string]struct{}
@@ -16495,6 +16496,55 @@ func (m *OutboundOrderMutation) ResetContractNo() {
 	delete(m.clearedFields, outboundorder.FieldContractNo)
 }
 
+// SetInspectionNo sets the "inspection_no" field.
+func (m *OutboundOrderMutation) SetInspectionNo(s string) {
+	m.inspection_no = &s
+}
+
+// InspectionNo returns the value of the "inspection_no" field in the mutation.
+func (m *OutboundOrderMutation) InspectionNo() (r string, exists bool) {
+	v := m.inspection_no
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldInspectionNo returns the old "inspection_no" field's value of the OutboundOrder entity.
+// If the OutboundOrder object wasn't provided to the builder, the object is fetched from the database.
+// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
+func (m *OutboundOrderMutation) OldInspectionNo(ctx context.Context) (v string, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, errors.New("OldInspectionNo is only allowed on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, errors.New("OldInspectionNo requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldInspectionNo: %w", err)
+	}
+	return oldValue.InspectionNo, nil
+}
+
+// ClearInspectionNo clears the value of the "inspection_no" field.
+func (m *OutboundOrderMutation) ClearInspectionNo() {
+	m.inspection_no = nil
+	m.clearedFields[outboundorder.FieldInspectionNo] = struct{}{}
+}
+
+// InspectionNoCleared returns if the "inspection_no" field was cleared in this mutation.
+func (m *OutboundOrderMutation) InspectionNoCleared() bool {
+	_, ok := m.clearedFields[outboundorder.FieldInspectionNo]
+	return ok
+}
+
+// ResetInspectionNo resets all changes to the "inspection_no" field.
+func (m *OutboundOrderMutation) ResetInspectionNo() {
+	m.inspection_no = nil
+	delete(m.clearedFields, outboundorder.FieldInspectionNo)
+}
+
 // SetCreatedAt sets the "created_at" field.
 func (m *OutboundOrderMutation) SetCreatedAt(i int64) {
 	m.created_at = &i
@@ -16585,7 +16635,7 @@ func (m *OutboundOrderMutation) Type() string {
 // order to get all numeric fields that were incremented/decremented, call
 // AddedFields().
 func (m *OutboundOrderMutation) Fields() []string {
-	fields := make([]string, 0, 26)
+	fields := make([]string, 0, 27)
 	if m.outbound_no != nil {
 		fields = append(fields, outboundorder.FieldOutboundNo)
 	}
@@ -16661,6 +16711,9 @@ func (m *OutboundOrderMutation) Fields() []string {
 	if m.contract_no != nil {
 		fields = append(fields, outboundorder.FieldContractNo)
 	}
+	if m.inspection_no != nil {
+		fields = append(fields, outboundorder.FieldInspectionNo)
+	}
 	if m.created_at != nil {
 		fields = append(fields, outboundorder.FieldCreatedAt)
 	}
@@ -16722,6 +16775,8 @@ func (m *OutboundOrderMutation) Field(name string) (ent.Value, bool) {
 		return m.BoxSnList()
 	case outboundorder.FieldContractNo:
 		return m.ContractNo()
+	case outboundorder.FieldInspectionNo:
+		return m.InspectionNo()
 	case outboundorder.FieldCreatedAt:
 		return m.CreatedAt()
 	}
@@ -16783,6 +16838,8 @@ func (m *OutboundOrderMutation) OldField(ctx context.Context, name string) (ent.
 		return m.OldBoxSnList(ctx)
 	case outboundorder.FieldContractNo:
 		return m.OldContractNo(ctx)
+	case outboundorder.FieldInspectionNo:
+		return m.OldInspectionNo(ctx)
 	case outboundorder.FieldCreatedAt:
 		return m.OldCreatedAt(ctx)
 	}
@@ -16969,6 +17026,13 @@ func (m *OutboundOrderMutation) SetField(name string, value ent.Value) error {
 		}
 		m.SetContractNo(v)
 		return nil
+	case outboundorder.FieldInspectionNo:
+		v, ok := value.(string)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetInspectionNo(v)
+		return nil
 	case outboundorder.FieldCreatedAt:
 		v, ok := value.(int64)
 		if !ok {
@@ -17099,6 +17163,9 @@ func (m *OutboundOrderMutation) ClearedFields() []string {
 	if m.FieldCleared(outboundorder.FieldContractNo) {
 		fields = append(fields, outboundorder.FieldContractNo)
 	}
+	if m.FieldCleared(outboundorder.FieldInspectionNo) {
+		fields = append(fields, outboundorder.FieldInspectionNo)
+	}
 	return fields
 }
 
@@ -17167,6 +17234,9 @@ func (m *OutboundOrderMutation) ClearField(name string) error {
 	case outboundorder.FieldContractNo:
 		m.ClearContractNo()
 		return nil
+	case outboundorder.FieldInspectionNo:
+		m.ClearInspectionNo()
+		return nil
 	}
 	return fmt.Errorf("unknown OutboundOrder nullable field %s", name)
 }
@@ -17250,6 +17320,9 @@ func (m *OutboundOrderMutation) ResetField(name string) error {
 	case outboundorder.FieldContractNo:
 		m.ResetContractNo()
 		return nil
+	case outboundorder.FieldInspectionNo:
+		m.ResetInspectionNo()
+		return nil
 	case outboundorder.FieldCreatedAt:
 		m.ResetCreatedAt()
 		return nil
diff --git a/bj_power_wms/ent/outboundorder.go b/bj_power_wms/ent/outboundorder.go
index d162637..362abcc 100644
--- a/bj_power_wms/ent/outboundorder.go
+++ b/bj_power_wms/ent/outboundorder.go
@@ -66,6 +66,8 @@ type OutboundOrder struct {
 	BoxSnList string `json:"boxSnList,omitempty"`
 	// 合同号(装箱选填)
 	ContractNo string `json:"contractNo,omitempty"`
+	// 检测单号(溯源关联检验单据)
+	InspectionNo string `json:"inspectionNo,omitempty"`
 	// 创建时间
 	CreatedAt    int64 `json:"createdAt,omitempty"`
 	selectValues sql.SelectValues
@@ -80,7 +82,7 @@ func (*OutboundOrder) scanValues(columns []string) ([]any, error) {
 			values[i] = new(sql.NullBool)
 		case outboundorder.FieldID, outboundorder.FieldManageMode, outboundorder.FieldQuantity, outboundorder.FieldCreatedAt:
 			values[i] = new(sql.NullInt64)
-		case outboundorder.FieldOutboundNo, outboundorder.FieldOutboundType, outboundorder.FieldStatus, outboundorder.FieldOutboundCategory, outboundorder.FieldOwnershipType, outboundorder.FieldOwnershipNo, outboundorder.FieldTargetStation, outboundorder.FieldOrderNo, outboundorder.FieldMaterialCode, outboundorder.FieldMaterialName, outboundorder.FieldBatchNo, outboundorder.FieldZoneCode, outboundorder.FieldShelfNo, outboundorder.FieldLayerNo, outboundorder.FieldPositionNo, outboundorder.FieldOperator, outboundorder.FieldReviewer, outboundorder.FieldTargetDock, outboundorder.FieldRemark, outboundorder.FieldBoxNo, outboundorder.FieldBoxSnList, outboundorder.FieldContractNo:
+		case outboundorder.FieldOutboundNo, outboundorder.FieldOutboundType, outboundorder.FieldStatus, outboundorder.FieldOutboundCategory, outboundorder.FieldOwnershipType, outboundorder.FieldOwnershipNo, outboundorder.FieldTargetStation, outboundorder.FieldOrderNo, outboundorder.FieldMaterialCode, outboundorder.FieldMaterialName, outboundorder.FieldBatchNo, outboundorder.FieldZoneCode, outboundorder.FieldShelfNo, outboundorder.FieldLayerNo, outboundorder.FieldPositionNo, outboundorder.FieldOperator, outboundorder.FieldReviewer, outboundorder.FieldTargetDock, outboundorder.FieldRemark, outboundorder.FieldBoxNo, outboundorder.FieldBoxSnList, outboundorder.FieldContractNo, outboundorder.FieldInspectionNo:
 			values[i] = new(sql.NullString)
 		default:
 			values[i] = new(sql.UnknownType)
@@ -253,6 +255,12 @@ func (_m *OutboundOrder) assignValues(columns []string, values []any) error {
 			} else if value.Valid {
 				_m.ContractNo = value.String
 			}
+		case outboundorder.FieldInspectionNo:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field inspection_no", values[i])
+			} else if value.Valid {
+				_m.InspectionNo = value.String
+			}
 		case outboundorder.FieldCreatedAt:
 			if value, ok := values[i].(*sql.NullInt64); !ok {
 				return fmt.Errorf("unexpected type %T for field created_at", values[i])
@@ -370,6 +378,9 @@ func (_m *OutboundOrder) String() string {
 	builder.WriteString("contract_no=")
 	builder.WriteString(_m.ContractNo)
 	builder.WriteString(", ")
+	builder.WriteString("inspection_no=")
+	builder.WriteString(_m.InspectionNo)
+	builder.WriteString(", ")
 	builder.WriteString("created_at=")
 	builder.WriteString(fmt.Sprintf("%v", _m.CreatedAt))
 	builder.WriteByte(')')
diff --git a/bj_power_wms/ent/outboundorder/outboundorder.go b/bj_power_wms/ent/outboundorder/outboundorder.go
index 08a33b6..1f163b2 100644
--- a/bj_power_wms/ent/outboundorder/outboundorder.go
+++ b/bj_power_wms/ent/outboundorder/outboundorder.go
@@ -61,6 +61,8 @@ const (
 	FieldBoxSnList = "box_sn_list"
 	// FieldContractNo holds the string denoting the contract_no field in the database.
 	FieldContractNo = "contract_no"
+	// FieldInspectionNo holds the string denoting the inspection_no field in the database.
+	FieldInspectionNo = "inspection_no"
 	// FieldCreatedAt holds the string denoting the created_at field in the database.
 	FieldCreatedAt = "created_at"
 	// Table holds the table name of the outboundorder in the database.
@@ -95,6 +97,7 @@ var Columns = []string{
 	FieldBoxNo,
 	FieldBoxSnList,
 	FieldContractNo,
+	FieldInspectionNo,
 	FieldCreatedAt,
 }
 
@@ -256,6 +259,11 @@ func ByContractNo(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldContractNo, opts...).ToFunc()
 }
 
+// ByInspectionNo orders the results by the inspection_no field.
+func ByInspectionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInspectionNo, opts...).ToFunc()
+}
+
 // ByCreatedAt orders the results by the created_at field.
 func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
 	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
diff --git a/bj_power_wms/ent/outboundorder/where.go b/bj_power_wms/ent/outboundorder/where.go
index 190c3d8..43c540c 100644
--- a/bj_power_wms/ent/outboundorder/where.go
+++ b/bj_power_wms/ent/outboundorder/where.go
@@ -178,6 +178,11 @@ func ContractNo(v string) predicate.OutboundOrder {
 	return predicate.OutboundOrder(sql.FieldEQ(FieldContractNo, v))
 }
 
+// InspectionNo applies equality check predicate on the "inspection_no" field. It's identical to InspectionNoEQ.
+func InspectionNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldInspectionNo, v))
+}
+
 // CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
 func CreatedAt(v int64) predicate.OutboundOrder {
 	return predicate.OutboundOrder(sql.FieldEQ(FieldCreatedAt, v))
@@ -1883,6 +1888,81 @@ func ContractNoContainsFold(v string) predicate.OutboundOrder {
 	return predicate.OutboundOrder(sql.FieldContainsFold(FieldContractNo, v))
 }
 
+// InspectionNoEQ applies the EQ predicate on the "inspection_no" field.
+func InspectionNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldInspectionNo, v))
+}
+
+// InspectionNoNEQ applies the NEQ predicate on the "inspection_no" field.
+func InspectionNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldInspectionNo, v))
+}
+
+// InspectionNoIn applies the In predicate on the "inspection_no" field.
+func InspectionNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldInspectionNo, vs...))
+}
+
+// InspectionNoNotIn applies the NotIn predicate on the "inspection_no" field.
+func InspectionNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldInspectionNo, vs...))
+}
+
+// InspectionNoGT applies the GT predicate on the "inspection_no" field.
+func InspectionNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldInspectionNo, v))
+}
+
+// InspectionNoGTE applies the GTE predicate on the "inspection_no" field.
+func InspectionNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldInspectionNo, v))
+}
+
+// InspectionNoLT applies the LT predicate on the "inspection_no" field.
+func InspectionNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldInspectionNo, v))
+}
+
+// InspectionNoLTE applies the LTE predicate on the "inspection_no" field.
+func InspectionNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldInspectionNo, v))
+}
+
+// InspectionNoContains applies the Contains predicate on the "inspection_no" field.
+func InspectionNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldInspectionNo, v))
+}
+
+// InspectionNoHasPrefix applies the HasPrefix predicate on the "inspection_no" field.
+func InspectionNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldInspectionNo, v))
+}
+
+// InspectionNoHasSuffix applies the HasSuffix predicate on the "inspection_no" field.
+func InspectionNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldInspectionNo, v))
+}
+
+// InspectionNoIsNil applies the IsNil predicate on the "inspection_no" field.
+func InspectionNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldInspectionNo))
+}
+
+// InspectionNoNotNil applies the NotNil predicate on the "inspection_no" field.
+func InspectionNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldInspectionNo))
+}
+
+// InspectionNoEqualFold applies the EqualFold predicate on the "inspection_no" field.
+func InspectionNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldInspectionNo, v))
+}
+
+// InspectionNoContainsFold applies the ContainsFold predicate on the "inspection_no" field.
+func InspectionNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldInspectionNo, v))
+}
+
 // CreatedAtEQ applies the EQ predicate on the "created_at" field.
 func CreatedAtEQ(v int64) predicate.OutboundOrder {
 	return predicate.OutboundOrder(sql.FieldEQ(FieldCreatedAt, v))
diff --git a/bj_power_wms/ent/outboundorder_create.go b/bj_power_wms/ent/outboundorder_create.go
index 341a5d0..7866295 100644
--- a/bj_power_wms/ent/outboundorder_create.go
+++ b/bj_power_wms/ent/outboundorder_create.go
@@ -355,6 +355,20 @@ func (_c *OutboundOrderCreate) SetNillableContractNo(v *string) *OutboundOrderCr
 	return _c
 }
 
+// SetInspectionNo sets the "inspection_no" field.
+func (_c *OutboundOrderCreate) SetInspectionNo(v string) *OutboundOrderCreate {
+	_c.mutation.SetInspectionNo(v)
+	return _c
+}
+
+// SetNillableInspectionNo sets the "inspection_no" field if the given value is not nil.
+func (_c *OutboundOrderCreate) SetNillableInspectionNo(v *string) *OutboundOrderCreate {
+	if v != nil {
+		_c.SetInspectionNo(*v)
+	}
+	return _c
+}
+
 // SetCreatedAt sets the "created_at" field.
 func (_c *OutboundOrderCreate) SetCreatedAt(v int64) *OutboundOrderCreate {
 	_c.mutation.SetCreatedAt(v)
@@ -583,6 +597,10 @@ func (_c *OutboundOrderCreate) createSpec() (*OutboundOrder, *sqlgraph.CreateSpe
 		_spec.SetField(outboundorder.FieldContractNo, field.TypeString, value)
 		_node.ContractNo = value
 	}
+	if value, ok := _c.mutation.InspectionNo(); ok {
+		_spec.SetField(outboundorder.FieldInspectionNo, field.TypeString, value)
+		_node.InspectionNo = value
+	}
 	if value, ok := _c.mutation.CreatedAt(); ok {
 		_spec.SetField(outboundorder.FieldCreatedAt, field.TypeInt64, value)
 		_node.CreatedAt = value
@@ -1059,6 +1077,24 @@ func (u *OutboundOrderUpsert) ClearContractNo() *OutboundOrderUpsert {
 	return u
 }
 
+// SetInspectionNo sets the "inspection_no" field.
+func (u *OutboundOrderUpsert) SetInspectionNo(v string) *OutboundOrderUpsert {
+	u.Set(outboundorder.FieldInspectionNo, v)
+	return u
+}
+
+// UpdateInspectionNo sets the "inspection_no" field to the value that was provided on create.
+func (u *OutboundOrderUpsert) UpdateInspectionNo() *OutboundOrderUpsert {
+	u.SetExcluded(outboundorder.FieldInspectionNo)
+	return u
+}
+
+// ClearInspectionNo clears the value of the "inspection_no" field.
+func (u *OutboundOrderUpsert) ClearInspectionNo() *OutboundOrderUpsert {
+	u.SetNull(outboundorder.FieldInspectionNo)
+	return u
+}
+
 // SetCreatedAt sets the "created_at" field.
 func (u *OutboundOrderUpsert) SetCreatedAt(v int64) *OutboundOrderUpsert {
 	u.Set(outboundorder.FieldCreatedAt, v)
@@ -1607,6 +1643,27 @@ func (u *OutboundOrderUpsertOne) ClearContractNo() *OutboundOrderUpsertOne {
 	})
 }
 
+// SetInspectionNo sets the "inspection_no" field.
+func (u *OutboundOrderUpsertOne) SetInspectionNo(v string) *OutboundOrderUpsertOne {
+	return u.Update(func(s *OutboundOrderUpsert) {
+		s.SetInspectionNo(v)
+	})
+}
+
+// UpdateInspectionNo sets the "inspection_no" field to the value that was provided on create.
+func (u *OutboundOrderUpsertOne) UpdateInspectionNo() *OutboundOrderUpsertOne {
+	return u.Update(func(s *OutboundOrderUpsert) {
+		s.UpdateInspectionNo()
+	})
+}
+
+// ClearInspectionNo clears the value of the "inspection_no" field.
+func (u *OutboundOrderUpsertOne) ClearInspectionNo() *OutboundOrderUpsertOne {
+	return u.Update(func(s *OutboundOrderUpsert) {
+		s.ClearInspectionNo()
+	})
+}
+
 // SetCreatedAt sets the "created_at" field.
 func (u *OutboundOrderUpsertOne) SetCreatedAt(v int64) *OutboundOrderUpsertOne {
 	return u.Update(func(s *OutboundOrderUpsert) {
@@ -2322,6 +2379,27 @@ func (u *OutboundOrderUpsertBulk) ClearContractNo() *OutboundOrderUpsertBulk {
 	})
 }
 
+// SetInspectionNo sets the "inspection_no" field.
+func (u *OutboundOrderUpsertBulk) SetInspectionNo(v string) *OutboundOrderUpsertBulk {
+	return u.Update(func(s *OutboundOrderUpsert) {
+		s.SetInspectionNo(v)
+	})
+}
+
+// UpdateInspectionNo sets the "inspection_no" field to the value that was provided on create.
+func (u *OutboundOrderUpsertBulk) UpdateInspectionNo() *OutboundOrderUpsertBulk {
+	return u.Update(func(s *OutboundOrderUpsert) {
+		s.UpdateInspectionNo()
+	})
+}
+
+// ClearInspectionNo clears the value of the "inspection_no" field.
+func (u *OutboundOrderUpsertBulk) ClearInspectionNo() *OutboundOrderUpsertBulk {
+	return u.Update(func(s *OutboundOrderUpsert) {
+		s.ClearInspectionNo()
+	})
+}
+
 // SetCreatedAt sets the "created_at" field.
 func (u *OutboundOrderUpsertBulk) SetCreatedAt(v int64) *OutboundOrderUpsertBulk {
 	return u.Update(func(s *OutboundOrderUpsert) {
diff --git a/bj_power_wms/ent/outboundorder_update.go b/bj_power_wms/ent/outboundorder_update.go
index cc3756d..a457b4a 100644
--- a/bj_power_wms/ent/outboundorder_update.go
+++ b/bj_power_wms/ent/outboundorder_update.go
@@ -499,6 +499,26 @@ func (_u *OutboundOrderUpdate) ClearContractNo() *OutboundOrderUpdate {
 	return _u
 }
 
+// SetInspectionNo sets the "inspection_no" field.
+func (_u *OutboundOrderUpdate) SetInspectionNo(v string) *OutboundOrderUpdate {
+	_u.mutation.SetInspectionNo(v)
+	return _u
+}
+
+// SetNillableInspectionNo sets the "inspection_no" field if the given value is not nil.
+func (_u *OutboundOrderUpdate) SetNillableInspectionNo(v *string) *OutboundOrderUpdate {
+	if v != nil {
+		_u.SetInspectionNo(*v)
+	}
+	return _u
+}
+
+// ClearInspectionNo clears the value of the "inspection_no" field.
+func (_u *OutboundOrderUpdate) ClearInspectionNo() *OutboundOrderUpdate {
+	_u.mutation.ClearInspectionNo()
+	return _u
+}
+
 // SetCreatedAt sets the "created_at" field.
 func (_u *OutboundOrderUpdate) SetCreatedAt(v int64) *OutboundOrderUpdate {
 	_u.mutation.ResetCreatedAt()
@@ -696,6 +716,12 @@ func (_u *OutboundOrderUpdate) sqlSave(ctx context.Context) (_node int, err erro
 	if _u.mutation.ContractNoCleared() {
 		_spec.ClearField(outboundorder.FieldContractNo, field.TypeString)
 	}
+	if value, ok := _u.mutation.InspectionNo(); ok {
+		_spec.SetField(outboundorder.FieldInspectionNo, field.TypeString, value)
+	}
+	if _u.mutation.InspectionNoCleared() {
+		_spec.ClearField(outboundorder.FieldInspectionNo, field.TypeString)
+	}
 	if value, ok := _u.mutation.CreatedAt(); ok {
 		_spec.SetField(outboundorder.FieldCreatedAt, field.TypeInt64, value)
 	}
@@ -1194,6 +1220,26 @@ func (_u *OutboundOrderUpdateOne) ClearContractNo() *OutboundOrderUpdateOne {
 	return _u
 }
 
+// SetInspectionNo sets the "inspection_no" field.
+func (_u *OutboundOrderUpdateOne) SetInspectionNo(v string) *OutboundOrderUpdateOne {
+	_u.mutation.SetInspectionNo(v)
+	return _u
+}
+
+// SetNillableInspectionNo sets the "inspection_no" field if the given value is not nil.
+func (_u *OutboundOrderUpdateOne) SetNillableInspectionNo(v *string) *OutboundOrderUpdateOne {
+	if v != nil {
+		_u.SetInspectionNo(*v)
+	}
+	return _u
+}
+
+// ClearInspectionNo clears the value of the "inspection_no" field.
+func (_u *OutboundOrderUpdateOne) ClearInspectionNo() *OutboundOrderUpdateOne {
+	_u.mutation.ClearInspectionNo()
+	return _u
+}
+
 // SetCreatedAt sets the "created_at" field.
 func (_u *OutboundOrderUpdateOne) SetCreatedAt(v int64) *OutboundOrderUpdateOne {
 	_u.mutation.ResetCreatedAt()
@@ -1421,6 +1467,12 @@ func (_u *OutboundOrderUpdateOne) sqlSave(ctx context.Context) (_node *OutboundO
 	if _u.mutation.ContractNoCleared() {
 		_spec.ClearField(outboundorder.FieldContractNo, field.TypeString)
 	}
+	if value, ok := _u.mutation.InspectionNo(); ok {
+		_spec.SetField(outboundorder.FieldInspectionNo, field.TypeString, value)
+	}
+	if _u.mutation.InspectionNoCleared() {
+		_spec.ClearField(outboundorder.FieldInspectionNo, field.TypeString)
+	}
 	if value, ok := _u.mutation.CreatedAt(); ok {
 		_spec.SetField(outboundorder.FieldCreatedAt, field.TypeInt64, value)
 	}
diff --git a/bj_power_wms/ent/runtime.go b/bj_power_wms/ent/runtime.go
index 3e66581..9d58779 100644
--- a/bj_power_wms/ent/runtime.go
+++ b/bj_power_wms/ent/runtime.go
@@ -390,7 +390,7 @@ func init() {
 	// outboundorder.DefaultQuantity holds the default value on creation for the quantity field.
 	outboundorder.DefaultQuantity = outboundorderDescQuantity.Default.(int)
 	// outboundorderDescCreatedAt is the schema descriptor for created_at field.
-	outboundorderDescCreatedAt := outboundorderFields[25].Descriptor()
+	outboundorderDescCreatedAt := outboundorderFields[26].Descriptor()
 	// outboundorder.DefaultCreatedAt holds the default value on creation for the created_at field.
 	outboundorder.DefaultCreatedAt = outboundorderDescCreatedAt.Default.(func() int64)
 	permissionFields := schema.Permission{}.Fields()
diff --git a/bj_power_wms/enttest/enttest.go b/bj_power_wms/enttest/enttest.go
new file mode 100644
index 0000000..125c010
--- /dev/null
+++ b/bj_power_wms/enttest/enttest.go
@@ -0,0 +1,85 @@
+// Code generated by ent, DO NOT EDIT.
+
+package enttest
+
+import (
+	"context"
+
+	"bj_power_wms"
+	// required by schema hooks.
+	_ "bj_power_wms/runtime"
+
+	"bj_power_wms/migrate"
+
+	"entgo.io/ent/dialect/sql/schema"
+)
+
+type (
+	// TestingT is the interface that is shared between
+	// testing.T and testing.B and used by enttest.
+	TestingT interface {
+		FailNow()
+		Error(...any)
+	}
+
+	// Option configures client creation.
+	Option func(*options)
+
+	options struct {
+		opts        []bj_power_wms.Option
+		migrateOpts []schema.MigrateOption
+	}
+)
+
+// WithOptions forwards options to client creation.
+func WithOptions(opts ...bj_power_wms.Option) Option {
+	return func(o *options) {
+		o.opts = append(o.opts, opts...)
+	}
+}
+
+// WithMigrateOptions forwards options to auto migration.
+func WithMigrateOptions(opts ...schema.MigrateOption) Option {
+	return func(o *options) {
+		o.migrateOpts = append(o.migrateOpts, opts...)
+	}
+}
+
+func newOptions(opts []Option) *options {
+	o := &options{}
+	for _, opt := range opts {
+		opt(o)
+	}
+	return o
+}
+
+// Open calls bj_power_wms.Open and auto-run migration.
+func Open(t TestingT, driverName, dataSourceName string, opts ...Option) *bj_power_wms.Client {
+	o := newOptions(opts)
+	c, err := bj_power_wms.Open(driverName, dataSourceName, o.opts...)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+	migrateSchema(t, c, o)
+	return c
+}
+
+// NewClient calls bj_power_wms.NewClient and auto-run migration.
+func NewClient(t TestingT, opts ...Option) *bj_power_wms.Client {
+	o := newOptions(opts)
+	c := bj_power_wms.NewClient(o.opts...)
+	migrateSchema(t, c, o)
+	return c
+}
+func migrateSchema(t TestingT, c *bj_power_wms.Client, o *options) {
+	tables, err := schema.CopyTables(migrate.Tables)
+	if err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+	if err := migrate.Create(context.Background(), c.Schema, tables, o.migrateOpts...); err != nil {
+		t.Error(err)
+		t.FailNow()
+	}
+}
diff --git a/bj_power_wms/eventlog/eventlog.go b/bj_power_wms/eventlog/eventlog.go
new file mode 100644
index 0000000..8c1bf11
--- /dev/null
+++ b/bj_power_wms/eventlog/eventlog.go
@@ -0,0 +1,111 @@
+// Code generated by ent, DO NOT EDIT.
+
+package eventlog
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the eventlog type in the database.
+	Label = "event_log"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldEventType holds the string denoting the event_type field in the database.
+	FieldEventType = "event_type"
+	// FieldOperator holds the string denoting the operator field in the database.
+	FieldOperator = "operator"
+	// FieldEntityType holds the string denoting the entity_type field in the database.
+	FieldEntityType = "entity_type"
+	// FieldEntityID holds the string denoting the entity_id field in the database.
+	FieldEntityID = "entity_id"
+	// FieldDescription holds the string denoting the description field in the database.
+	FieldDescription = "description"
+	// FieldPayload holds the string denoting the payload field in the database.
+	FieldPayload = "payload"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// Table holds the table name of the eventlog in the database.
+	Table = "event_log"
+)
+
+// Columns holds all SQL columns for eventlog fields.
+var Columns = []string{
+	FieldID,
+	FieldEventType,
+	FieldOperator,
+	FieldEntityType,
+	FieldEntityID,
+	FieldDescription,
+	FieldPayload,
+	FieldCreatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// EventTypeValidator is a validator for the "event_type" field. It is called by the builders before save.
+	EventTypeValidator func(string) error
+	// DefaultOperator holds the default value on creation for the "operator" field.
+	DefaultOperator string
+	// OperatorValidator is a validator for the "operator" field. It is called by the builders before save.
+	OperatorValidator func(string) error
+	// DefaultEntityType holds the default value on creation for the "entity_type" field.
+	DefaultEntityType string
+	// EntityTypeValidator is a validator for the "entity_type" field. It is called by the builders before save.
+	EntityTypeValidator func(string) error
+	// DefaultEntityID holds the default value on creation for the "entity_id" field.
+	DefaultEntityID string
+	// EntityIDValidator is a validator for the "entity_id" field. It is called by the builders before save.
+	EntityIDValidator func(string) error
+	// DefaultDescription holds the default value on creation for the "description" field.
+	DefaultDescription string
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the EventLog queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByEventType orders the results by the event_type field.
+func ByEventType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldEventType, opts...).ToFunc()
+}
+
+// ByOperator orders the results by the operator field.
+func ByOperator(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOperator, opts...).ToFunc()
+}
+
+// ByEntityType orders the results by the entity_type field.
+func ByEntityType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldEntityType, opts...).ToFunc()
+}
+
+// ByEntityID orders the results by the entity_id field.
+func ByEntityID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldEntityID, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/eventlog/where.go b/bj_power_wms/eventlog/where.go
new file mode 100644
index 0000000..202e57c
--- /dev/null
+++ b/bj_power_wms/eventlog/where.go
@@ -0,0 +1,474 @@
+// Code generated by ent, DO NOT EDIT.
+
+package eventlog
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLTE(FieldID, id))
+}
+
+// EventType applies equality check predicate on the "event_type" field. It's identical to EventTypeEQ.
+func EventType(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldEventType, v))
+}
+
+// Operator applies equality check predicate on the "operator" field. It's identical to OperatorEQ.
+func Operator(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldOperator, v))
+}
+
+// EntityType applies equality check predicate on the "entity_type" field. It's identical to EntityTypeEQ.
+func EntityType(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldEntityType, v))
+}
+
+// EntityID applies equality check predicate on the "entity_id" field. It's identical to EntityIDEQ.
+func EntityID(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldEntityID, v))
+}
+
+// Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ.
+func Description(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldDescription, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// EventTypeEQ applies the EQ predicate on the "event_type" field.
+func EventTypeEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldEventType, v))
+}
+
+// EventTypeNEQ applies the NEQ predicate on the "event_type" field.
+func EventTypeNEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNEQ(FieldEventType, v))
+}
+
+// EventTypeIn applies the In predicate on the "event_type" field.
+func EventTypeIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldIn(FieldEventType, vs...))
+}
+
+// EventTypeNotIn applies the NotIn predicate on the "event_type" field.
+func EventTypeNotIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNotIn(FieldEventType, vs...))
+}
+
+// EventTypeGT applies the GT predicate on the "event_type" field.
+func EventTypeGT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGT(FieldEventType, v))
+}
+
+// EventTypeGTE applies the GTE predicate on the "event_type" field.
+func EventTypeGTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGTE(FieldEventType, v))
+}
+
+// EventTypeLT applies the LT predicate on the "event_type" field.
+func EventTypeLT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLT(FieldEventType, v))
+}
+
+// EventTypeLTE applies the LTE predicate on the "event_type" field.
+func EventTypeLTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLTE(FieldEventType, v))
+}
+
+// EventTypeContains applies the Contains predicate on the "event_type" field.
+func EventTypeContains(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContains(FieldEventType, v))
+}
+
+// EventTypeHasPrefix applies the HasPrefix predicate on the "event_type" field.
+func EventTypeHasPrefix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasPrefix(FieldEventType, v))
+}
+
+// EventTypeHasSuffix applies the HasSuffix predicate on the "event_type" field.
+func EventTypeHasSuffix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasSuffix(FieldEventType, v))
+}
+
+// EventTypeEqualFold applies the EqualFold predicate on the "event_type" field.
+func EventTypeEqualFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEqualFold(FieldEventType, v))
+}
+
+// EventTypeContainsFold applies the ContainsFold predicate on the "event_type" field.
+func EventTypeContainsFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContainsFold(FieldEventType, v))
+}
+
+// OperatorEQ applies the EQ predicate on the "operator" field.
+func OperatorEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldOperator, v))
+}
+
+// OperatorNEQ applies the NEQ predicate on the "operator" field.
+func OperatorNEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNEQ(FieldOperator, v))
+}
+
+// OperatorIn applies the In predicate on the "operator" field.
+func OperatorIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldIn(FieldOperator, vs...))
+}
+
+// OperatorNotIn applies the NotIn predicate on the "operator" field.
+func OperatorNotIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNotIn(FieldOperator, vs...))
+}
+
+// OperatorGT applies the GT predicate on the "operator" field.
+func OperatorGT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGT(FieldOperator, v))
+}
+
+// OperatorGTE applies the GTE predicate on the "operator" field.
+func OperatorGTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGTE(FieldOperator, v))
+}
+
+// OperatorLT applies the LT predicate on the "operator" field.
+func OperatorLT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLT(FieldOperator, v))
+}
+
+// OperatorLTE applies the LTE predicate on the "operator" field.
+func OperatorLTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLTE(FieldOperator, v))
+}
+
+// OperatorContains applies the Contains predicate on the "operator" field.
+func OperatorContains(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContains(FieldOperator, v))
+}
+
+// OperatorHasPrefix applies the HasPrefix predicate on the "operator" field.
+func OperatorHasPrefix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasPrefix(FieldOperator, v))
+}
+
+// OperatorHasSuffix applies the HasSuffix predicate on the "operator" field.
+func OperatorHasSuffix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasSuffix(FieldOperator, v))
+}
+
+// OperatorEqualFold applies the EqualFold predicate on the "operator" field.
+func OperatorEqualFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEqualFold(FieldOperator, v))
+}
+
+// OperatorContainsFold applies the ContainsFold predicate on the "operator" field.
+func OperatorContainsFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContainsFold(FieldOperator, v))
+}
+
+// EntityTypeEQ applies the EQ predicate on the "entity_type" field.
+func EntityTypeEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldEntityType, v))
+}
+
+// EntityTypeNEQ applies the NEQ predicate on the "entity_type" field.
+func EntityTypeNEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNEQ(FieldEntityType, v))
+}
+
+// EntityTypeIn applies the In predicate on the "entity_type" field.
+func EntityTypeIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldIn(FieldEntityType, vs...))
+}
+
+// EntityTypeNotIn applies the NotIn predicate on the "entity_type" field.
+func EntityTypeNotIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNotIn(FieldEntityType, vs...))
+}
+
+// EntityTypeGT applies the GT predicate on the "entity_type" field.
+func EntityTypeGT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGT(FieldEntityType, v))
+}
+
+// EntityTypeGTE applies the GTE predicate on the "entity_type" field.
+func EntityTypeGTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGTE(FieldEntityType, v))
+}
+
+// EntityTypeLT applies the LT predicate on the "entity_type" field.
+func EntityTypeLT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLT(FieldEntityType, v))
+}
+
+// EntityTypeLTE applies the LTE predicate on the "entity_type" field.
+func EntityTypeLTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLTE(FieldEntityType, v))
+}
+
+// EntityTypeContains applies the Contains predicate on the "entity_type" field.
+func EntityTypeContains(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContains(FieldEntityType, v))
+}
+
+// EntityTypeHasPrefix applies the HasPrefix predicate on the "entity_type" field.
+func EntityTypeHasPrefix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasPrefix(FieldEntityType, v))
+}
+
+// EntityTypeHasSuffix applies the HasSuffix predicate on the "entity_type" field.
+func EntityTypeHasSuffix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasSuffix(FieldEntityType, v))
+}
+
+// EntityTypeEqualFold applies the EqualFold predicate on the "entity_type" field.
+func EntityTypeEqualFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEqualFold(FieldEntityType, v))
+}
+
+// EntityTypeContainsFold applies the ContainsFold predicate on the "entity_type" field.
+func EntityTypeContainsFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContainsFold(FieldEntityType, v))
+}
+
+// EntityIDEQ applies the EQ predicate on the "entity_id" field.
+func EntityIDEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldEntityID, v))
+}
+
+// EntityIDNEQ applies the NEQ predicate on the "entity_id" field.
+func EntityIDNEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNEQ(FieldEntityID, v))
+}
+
+// EntityIDIn applies the In predicate on the "entity_id" field.
+func EntityIDIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldIn(FieldEntityID, vs...))
+}
+
+// EntityIDNotIn applies the NotIn predicate on the "entity_id" field.
+func EntityIDNotIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNotIn(FieldEntityID, vs...))
+}
+
+// EntityIDGT applies the GT predicate on the "entity_id" field.
+func EntityIDGT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGT(FieldEntityID, v))
+}
+
+// EntityIDGTE applies the GTE predicate on the "entity_id" field.
+func EntityIDGTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGTE(FieldEntityID, v))
+}
+
+// EntityIDLT applies the LT predicate on the "entity_id" field.
+func EntityIDLT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLT(FieldEntityID, v))
+}
+
+// EntityIDLTE applies the LTE predicate on the "entity_id" field.
+func EntityIDLTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLTE(FieldEntityID, v))
+}
+
+// EntityIDContains applies the Contains predicate on the "entity_id" field.
+func EntityIDContains(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContains(FieldEntityID, v))
+}
+
+// EntityIDHasPrefix applies the HasPrefix predicate on the "entity_id" field.
+func EntityIDHasPrefix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasPrefix(FieldEntityID, v))
+}
+
+// EntityIDHasSuffix applies the HasSuffix predicate on the "entity_id" field.
+func EntityIDHasSuffix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasSuffix(FieldEntityID, v))
+}
+
+// EntityIDEqualFold applies the EqualFold predicate on the "entity_id" field.
+func EntityIDEqualFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEqualFold(FieldEntityID, v))
+}
+
+// EntityIDContainsFold applies the ContainsFold predicate on the "entity_id" field.
+func EntityIDContainsFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContainsFold(FieldEntityID, v))
+}
+
+// DescriptionEQ applies the EQ predicate on the "description" field.
+func DescriptionEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldDescription, v))
+}
+
+// DescriptionNEQ applies the NEQ predicate on the "description" field.
+func DescriptionNEQ(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNEQ(FieldDescription, v))
+}
+
+// DescriptionIn applies the In predicate on the "description" field.
+func DescriptionIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldIn(FieldDescription, vs...))
+}
+
+// DescriptionNotIn applies the NotIn predicate on the "description" field.
+func DescriptionNotIn(vs ...string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNotIn(FieldDescription, vs...))
+}
+
+// DescriptionGT applies the GT predicate on the "description" field.
+func DescriptionGT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGT(FieldDescription, v))
+}
+
+// DescriptionGTE applies the GTE predicate on the "description" field.
+func DescriptionGTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGTE(FieldDescription, v))
+}
+
+// DescriptionLT applies the LT predicate on the "description" field.
+func DescriptionLT(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLT(FieldDescription, v))
+}
+
+// DescriptionLTE applies the LTE predicate on the "description" field.
+func DescriptionLTE(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLTE(FieldDescription, v))
+}
+
+// DescriptionContains applies the Contains predicate on the "description" field.
+func DescriptionContains(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContains(FieldDescription, v))
+}
+
+// DescriptionHasPrefix applies the HasPrefix predicate on the "description" field.
+func DescriptionHasPrefix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasPrefix(FieldDescription, v))
+}
+
+// DescriptionHasSuffix applies the HasSuffix predicate on the "description" field.
+func DescriptionHasSuffix(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldHasSuffix(FieldDescription, v))
+}
+
+// DescriptionEqualFold applies the EqualFold predicate on the "description" field.
+func DescriptionEqualFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEqualFold(FieldDescription, v))
+}
+
+// DescriptionContainsFold applies the ContainsFold predicate on the "description" field.
+func DescriptionContainsFold(v string) predicate.EventLog {
+	return predicate.EventLog(sql.FieldContainsFold(FieldDescription, v))
+}
+
+// PayloadIsNil applies the IsNil predicate on the "payload" field.
+func PayloadIsNil() predicate.EventLog {
+	return predicate.EventLog(sql.FieldIsNull(FieldPayload))
+}
+
+// PayloadNotNil applies the NotNil predicate on the "payload" field.
+func PayloadNotNil() predicate.EventLog {
+	return predicate.EventLog(sql.FieldNotNull(FieldPayload))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.EventLog {
+	return predicate.EventLog(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.EventLog) predicate.EventLog {
+	return predicate.EventLog(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.EventLog) predicate.EventLog {
+	return predicate.EventLog(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.EventLog) predicate.EventLog {
+	return predicate.EventLog(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/frontend/src/pages/BaseData.vue b/bj_power_wms/frontend/src/pages/BaseData.vue
index ca56788..7faf7c3 100644
--- a/bj_power_wms/frontend/src/pages/BaseData.vue
+++ b/bj_power_wms/frontend/src/pages/BaseData.vue
@@ -917,8 +917,8 @@ async function onMaterialFile(e) {
           </el-table-column>
           <el-table-column label="类型" width="140" align="center">
             <template #default="{ row }">
-              <el-tag :type="row.manageMode === 2 ? 'warning' : 'info'" size="small">
-                {{ row.manageMode === 2 ? '电气件(SN)' : '结构件(批次)' }}
+              <el-tag :type="row.itemType === 4 ? 'info' : (row.manageMode === 2 ? 'warning' : 'primary')" size="small">
+                {{ row.itemType === 4 ? '其他' : (row.manageMode === 2 ? '电气件(SN)' : '结构件(批次)') }}
               </el-tag>
             </template>
           </el-table-column>
@@ -967,8 +967,13 @@ async function onMaterialFile(e) {
             </el-form-item>
             <el-form-item label="类型" required>
               <el-select v-model="mForm.manageMode" placeholder="请选择" style="width:100%" :disabled="Number(mForm.itemType) === 4">
-                <el-option :value="1" label="结构件（批次管理）" />
-                <el-option :value="2" label="电气件（SN 管理）" />
+                <template v-if="Number(mForm.itemType) === 4">
+                  <el-option :value="1" label="其他（辅料/工装/试验设备）" />
+                </template>
+                <template v-else>
+                  <el-option :value="1" label="结构件（批次管理）" />
+                  <el-option :value="2" label="电气件（SN 管理）" />
+                </template>
               </el-select>
             </el-form-item>
             <el-form-item label="安全库存" required>
diff --git a/bj_power_wms/frontend/src/pages/Inbound.vue b/bj_power_wms/frontend/src/pages/Inbound.vue
index 08ac24c..296963e 100644
--- a/bj_power_wms/frontend/src/pages/Inbound.vue
+++ b/bj_power_wms/frontend/src/pages/Inbound.vue
@@ -91,7 +91,7 @@ const batchRef = ref()
 const submitting1 = ref(false)
 const lastInboundNo = ref('')
 const form1 = reactive({
-  materialCode: '', batchNo: '', quantity: 1,
+  inboundNo: '', materialCode: '', batchNo: '', quantity: 1,
   zoneCode: '', shelfNo: '', layerNo: '', positionNo: '',
   ownershipType: '', ownershipNo: '',
   productionDate: '', supplier: '', remark: '', inspectionNo: ''
@@ -124,6 +124,7 @@ async function submitBatch() {
   submitting1.value = true
   try {
     const data = await request.post('/inbound/create', {
+      inboundNo: form1.inboundNo.trim(),
       inboundType: 'purchase',
       materialCode: form1.materialCode,
       batchNo: form1.batchNo.trim(),
@@ -157,7 +158,7 @@ async function submitBatch() {
 const snInput = ref('')
 const submitting2 = ref(false)
 const snList = ref([])
-const form2 = reactive({ materialCode: '', zoneCode: '', shelfNo: '', layerNo: '', positionNo: '', ownershipType: '', ownershipNo: '', remark: '', inspectionNo: '' })
+const form2 = reactive({ inboundNo: '', materialCode: '', zoneCode: '', shelfNo: '', layerNo: '', positionNo: '', ownershipType: '', ownershipNo: '', remark: '', inspectionNo: '' })
 // 与 Tab1/Tab3 对齐：走 el-form 校验，必填项既爆红又弹窗
 const form2Ref = ref(null)
 const rules2 = {
@@ -205,6 +206,7 @@ async function submitSn() {
   submitting2.value = true
   try {
     const data = await request.post('/inbound/create', {
+      inboundNo: form2.inboundNo.trim(),
       inboundType: 'purchase',
       materialCode: form2.materialCode,
       zoneCode: form2.zoneCode,
@@ -275,6 +277,7 @@ async function importExcel(mode, which) {
 const otherRef = ref()
 const submitting3 = ref(false)
 const form3 = reactive({
+  inboundNo: '',
   materialCode: '', batchNo: '', quantity: 1, zoneCode: '',
   shelfNo: '', layerNo: '', positionNo: '',
   ownershipType: '', ownershipNo: '',
@@ -322,6 +325,7 @@ async function submitOther() {
   submitting3.value = true
   try {
     const data = await request.post('/inbound/create', {
+      inboundNo: form3.inboundNo.trim(),
       inboundType: 'other',
       materialCode: form3.materialCode,
       batchNo: form3.batchNo.trim(),
@@ -352,7 +356,7 @@ async function submitOther() {
 
 /* ===================== Tab4 入库记录（统一主表 + 抽屉明细，不分页内嵌子表） ===================== */
 // 查询条件
-const filters = reactive({ inboundNo: '', materialCode: '', manageMode: '', materialName: '', voided: '' })
+const filters = reactive({ inboundNo: '', materialCode: '', manageMode: '', materialName: '', voided: '', inspectionNo: '' })
 const dateRange = ref([]) // [开始日期, 结束日期] YYYY-MM-DD
 const loadingRec = ref(false)
 const list = ref([])
@@ -370,6 +374,7 @@ async function loadRecords() {
         manageMode: filters.manageMode === 'other' ? '' : filters.manageMode,
         inboundType: filters.manageMode === 'other' ? 'other' : '',
         materialName: filters.materialName.trim(),
+        inspectionNo: filters.inspectionNo.trim(),
         voided: filters.voided,
         startDate: dateRange.value?.[0] || '',
         endDate: dateRange.value?.[1] || '',
@@ -393,6 +398,7 @@ function resetFilters() {
   filters.materialCode = ''
   filters.manageMode = ''
   filters.materialName = ''
+  filters.inspectionNo = ''
   filters.voided = ''
   dateRange.value = []
   search()
@@ -437,6 +443,7 @@ async function exportCsv() {
       manageMode: filters.manageMode === 'other' ? '' : filters.manageMode,
       inboundType: filters.manageMode === 'other' ? 'other' : '',
       materialName: filters.materialName.trim(),
+      inspectionNo: filters.inspectionNo.trim(),
       voided: filters.voided,
       startDate: dateRange.value?.[0] || '',
       endDate: dateRange.value?.[1] || ''
@@ -447,10 +454,10 @@ async function exportCsv() {
 }
 
 // 入库单明细：点击"明细"用右侧抽屉懒加载 + 分页（不在列表内嵌子表，避免表格套表格）
-const detailDrawer = reactive({ visible: false, inboundNo: '', list: [], total: 0, page: 1, size: 50, loading: false, loaded: false })
+const detailDrawer = reactive({ visible: false, inboundNo: '', list: [], total: 0, page: 1, size: 20, loading: false, loaded: false })
 async function openDetail(row) {
   const no = row.inboundNo
-  Object.assign(detailDrawer, { visible: true, inboundNo: no, list: [], total: 0, page: 1, size: 50, loaded: false })
+  Object.assign(detailDrawer, { visible: true, inboundNo: no, list: [], total: 0, page: 1, size: 20, loaded: false })
   await fetchDetailPage()
 }
 async function fetchDetailPage() {
@@ -657,6 +664,9 @@ onActivated(() => {
                           placeholder="请填写归属编号" clearable style="width:260px" />
               </el-form-item>
             </el-form-item>
+            <el-form-item label="入库单号">
+              <el-input v-model="form1.inboundNo" placeholder="留空自动生成（如 IB20260921-001）" clearable />
+            </el-form-item>
             <el-form-item label="检测单号" prop="inspectionNo">
               <el-input v-model="form1.inspectionNo" placeholder="入库检报告单号（必填）" clearable />
             </el-form-item>
@@ -747,6 +757,9 @@ onActivated(() => {
                           placeholder="请填写归属编号" clearable style="width:260px" />
               </el-form-item>
             </el-form-item>
+            <el-form-item label="入库单号">
+              <el-input v-model="form2.inboundNo" placeholder="留空自动生成（如 IB20260921-001）" clearable />
+            </el-form-item>
             <el-form-item label="检测单号" prop="inspectionNo">
               <el-input v-model="form2.inspectionNo" placeholder="入库检报告单号（必填）" clearable />
             </el-form-item>
@@ -855,6 +868,9 @@ onActivated(() => {
             <el-form-item label="供应商">
               <el-input v-model="form3.supplier" placeholder="供应商名称（可空）" clearable />
             </el-form-item>
+            <el-form-item label="入库单号">
+              <el-input v-model="form3.inboundNo" placeholder="留空自动生成（如 IB20260921-001）" clearable />
+            </el-form-item>
             <el-form-item label="检测单号" prop="inspectionNo">
               <el-input v-model="form3.inspectionNo" placeholder="入库检报告单号（必填）" clearable />
             </el-form-item>
@@ -898,6 +914,9 @@ onActivated(() => {
             <el-form-item label="物料名称">
               <el-input v-model="filters.materialName" placeholder="物料名称(模糊)" clearable style="width:160px" @keyup.enter="search" />
             </el-form-item>
+            <el-form-item label="检测单号">
+              <el-input v-model="filters.inspectionNo" placeholder="检测单号(模糊)" clearable style="width:180px" @keyup.enter="search" />
+            </el-form-item>
             <el-form-item label="状态">
               <el-select v-model="filters.voided" placeholder="全部" clearable style="width:120px" @change="search">
                 <el-option label="有效" value="false" />
diff --git a/bj_power_wms/frontend/src/pages/Inspection.vue b/bj_power_wms/frontend/src/pages/Inspection.vue
index 7e077b1..7ad74d1 100644
--- a/bj_power_wms/frontend/src/pages/Inspection.vue
+++ b/bj_power_wms/frontend/src/pages/Inspection.vue
@@ -211,11 +211,7 @@ async function submitInspection() {
     manufacturer.value = ''
     await loadRecords()
     if (allPass && passedNo) {
-      try {
-        await ElMessageBox.confirm(`检验合格，是否携检测单号 ${passedNo} 前往入库？`, '前往入库',
-          { type: 'success', confirmButtonText: '去入库', cancelButtonText: '留在本页' })
-        router.push({ path: '/inbound', query: { inspectionNo: passedNo } })
-      } catch { /* 用户选择留在本页 */ }
+      ElMessage.success(`检验合格，检测单号 ${passedNo}`)
     }
   } finally {
     submitting.value = false
@@ -228,7 +224,44 @@ const pendingLoading = ref(false)
 const pendingRows = ref([])
 const pendingTotal = ref(0)
 const pendingPage = reactive({ current: 1, size: 20 })
-const pendingSelected = ref([]) // 选中的明细 targetId 集合（跨行）
+
+// 抽屉：右侧滑出，分页加载该入库单+物料的未检明细（替代原 el-table type="expand" 嵌套子表）
+const detailDrawer = reactive({
+  visible: false,
+  row: null,         // 主行快照（inboundNo/materialCode/ownership 等，整单送检/带入时用）
+  list: [],          // 当前页明细
+  total: 0,          // 明细总数
+  page: 1,
+  size: 20,
+  loading: false,
+  selected: []       // 抽屉内勾选的 targetId 集合
+})
+const detailDrawerSelectedIds = computed(() => new Set(detailDrawer.selected))
+
+function openDetailDrawer(row) {
+  Object.assign(detailDrawer, {
+    visible: true, row: { ...row },
+    list: [], total: 0, page: 1, size: 20, loading: false, selected: []
+  })
+  fetchDetailDrawerPage()
+}
+async function fetchDetailDrawerPage() {
+  const st = detailDrawer
+  st.loading = true
+  try {
+    const d = await request.get('/inspection/pending/details', {
+      params: { inboundNo: st.row.inboundNo, materialCode: st.row.materialCode, page: st.page, pageSize: st.size }
+    })
+    st.list = d?.list || []
+    st.total = d?.total || 0
+  } finally {
+    st.loading = false
+  }
+}
+function changeDetailDrawerPage(p) {
+  detailDrawer.page = p
+  fetchDetailDrawerPage()
+}
 
 const inboundTypeLabel = (t) => {
   const m = { purchase: '采购入库', semi: '半成品入库', finished: '成品入库', return: '退库入库', other: '其他入库' }
@@ -259,28 +292,37 @@ function searchPending() {
   pendingPage.current = 1
   loadPending()
 }
-// 整单送检 / 单条送检 / 选中送检
-function sendWhole(row) {
-  sendToEntry(row.details || [], row)
+
+// 整单送检：直接按 inboundNo+materialCode 拉全量未检明细（pageSize=99999，一次入库单 3000 条可接受）
+async function sendWhole(row) {
+  const d = await request.get('/inspection/pending/details', {
+    params: { inboundNo: row.inboundNo, materialCode: row.materialCode, page: 1, pageSize: 99999 }
+  })
+  const details = d?.list || []
+  sendToEntry(details, row)
 }
-function sendOne(row, detail) {
-  sendToEntry([detail], row)
+function sendOneFromDrawer(detail) {
+  sendToEntry([detail], detailDrawer.row)
 }
-function sendSelected() {
-  if (!pendingSelected.value.length) {
+function sendSelectedFromDrawer() {
+  if (!detailDrawer.selected.length) {
     ElMessage.warning('请先勾选要送检的批次/SN')
     return
   }
-  const details = []
-  for (const row of pendingRows.value) {
-    for (const d of row.details || []) {
-      if (pendingSelected.value.includes(d.targetId)) details.push(d)
-    }
+  if (detailDrawer.selected.length > 100) {
+    ElMessageBox.confirm('单次送检上限 100 条，请分批送检。', '提示', { type: 'warning', confirmButtonText: '知道了', showCancelButton: false })
+    return
   }
-  // 归属取首个命中行的入库单
-  const firstRow = pendingRows.value.find((r) => (r.details || []).some((d) => pendingSelected.value.includes(d.targetId)))
-  sendToEntry(details, firstRow)
-  pendingSelected.value = []
+  // 合并已加载页里的选中项 + 翻页选中的项（用 total details 拉全量过滤，避免跨页丢选）
+  // 但跨页选中无法从当前抽屉 list 覆盖，用全量过滤 targetId
+  const ids = new Set(detailDrawer.selected)
+  request.get('/inspection/pending/details', {
+    params: { inboundNo: detailDrawer.row.inboundNo, materialCode: detailDrawer.row.materialCode, page: 1, pageSize: 99999 }
+  }).then((d) => {
+    const details = (d?.list || []).filter((x) => ids.has(x.targetId))
+    sendToEntry(details, detailDrawer.row)
+    detailDrawer.selected = []
+  })
 }
 
 /* ===================== 不合格处置 ===================== */
@@ -590,38 +632,11 @@ onMounted(() => {
             </el-form-item>
             <el-form-item>
               <el-button type="primary" :loading="pendingLoading" @click="searchPending">查询</el-button>
-              <el-button :disabled="!pendingSelected.length" @click="sendSelected">送检选中 ({{ pendingSelected.length }})</el-button>
             </el-form-item>
           </el-form>
         </el-card>
-        <el-card shadow="never" header="待检清单（quality_status=未检，按入库单分组，点开看批次/SN 明细）">
-          <el-table :data="pendingRows" border size="small" v-loading="pendingLoading" empty-text="暂无待检（全部已检）" row-key="inboundNo">
-            <el-table-column type="expand">
-              <template #default="{ row }">
-                <el-table :data="row.details" border size="small" style="width:100%">
-                  <el-table-column width="50" align="center">
-                    <template #default="{ row: d }">
-                      <el-checkbox :model-value="pendingSelected.includes(d.targetId)" @change="(v)=>{ v ? pendingSelected.push(d.targetId) : pendingSelected = pendingSelected.filter(x=>x!==d.targetId) }" />
-                    </template>
-                  </el-table-column>
-                  <el-table-column label="编号" prop="targetId" min-width="160" />
-                  <el-table-column label="类型" width="80" align="center">
-                    <template #default="{ row: d }">{{ pendingTargetLabel(d) }}</template>
-                  </el-table-column>
-                  <el-table-column label="数量" width="80" align="center">
-                    <template #default="{ row: d }">{{ d.quantity }}</template>
-                  </el-table-column>
-                  <el-table-column label="区域" width="100" align="center">
-                    <template #default="{ row: d }">{{ d.zoneCode || '未分区' }}</template>
-                  </el-table-column>
-                  <el-table-column label="操作" width="100" align="center">
-                    <template #default="{ row: d }">
-                      <el-button link type="success" size="small" @click="sendOne(row, d)">送检此条</el-button>
-                    </template>
-                  </el-table-column>
-                </el-table>
-              </template>
-            </el-table-column>
+        <el-card shadow="never" header="待检清单（quality_status=未检，按入库单分组；点「查看明细」右侧抽屉）">
+          <el-table :data="pendingRows" border size="small" v-loading="pendingLoading" empty-text="暂无待检（全部已检）">
             <el-table-column prop="inboundNo" label="入库单号" min-width="160" />
             <el-table-column label="入库类型" width="110" align="center">
               <template #default="{ row }">{{ inboundTypeLabel(row.inboundType) }}</template>
@@ -633,8 +648,8 @@ onMounted(() => {
             <el-table-column label="未检数量" width="100" align="center">
               <template #default="{ row }">{{ row.unInspectedQty }}</template>
             </el-table-column>
-            <el-table-column label="批次/SN数" width="100" align="center">
-              <template #default="{ row }">{{ row.batchSnCount }}</template>
+            <el-table-column label="未检条数" width="100" align="center">
+              <template #default="{ row }">{{ row.detailsTotal }}</template>
             </el-table-column>
             <el-table-column label="归属" min-width="160" align="center">
               <template #default="{ row }">
@@ -645,8 +660,9 @@ onMounted(() => {
             <el-table-column label="入库时间" width="155" align="center">
               <template #default="{ row }">{{ row.inboundTime ? fmtTime(row.inboundTime) : '-' }}</template>
             </el-table-column>
-            <el-table-column label="操作" width="110" align="center" fixed="right">
+            <el-table-column label="操作" width="170" align="center" fixed="right">
               <template #default="{ row }">
+                <el-button link type="primary" size="small" @click="openDetailDrawer(row)">查看明细</el-button>
                 <el-button link type="success" size="small" @click="sendWhole(row)">整单送检</el-button>
               </template>
             </el-table-column>
@@ -813,6 +829,53 @@ onMounted(() => {
       </el-tab-pane>
     </el-tabs>
 
+    <!-- 待检清单明细抽屉（替代原 expand 嵌套子表，后端分页每页 20） -->
+    <el-drawer v-model="detailDrawer.visible"
+               :title="`待检明细：${detailDrawer.row?.inboundNo} · ${detailDrawer.row?.materialCode}`"
+               size="640px" destroy-on-close>
+      <div v-if="detailDrawer.row" style="margin-bottom:10px">
+        <el-tag type="info" size="small">{{ inboundTypeLabel(detailDrawer.row.inboundType) }}</el-tag>
+        <el-tag size="small" style="margin-left:6px">{{ detailDrawer.row.materialName || '-' }}</el-tag>
+        <el-tag size="small" style="margin-left:6px">{{ ownershipTypeLabel(detailDrawer.row.ownershipType) }}：{{ detailDrawer.row.ownershipNo || '-' }}</el-tag>
+      </div>
+      <el-table :data="detailDrawer.list" border size="small" v-loading="detailDrawer.loading" empty-text="暂无明细">
+        <el-table-column width="50" align="center">
+          <template #default="{ row }">
+            <el-checkbox :model-value="detailDrawerSelectedIds.has(row.targetId)"
+                         @change="(v) => { v ? detailDrawer.selected.push(row.targetId) : (detailDrawer.selected = detailDrawer.selected.filter(x => x !== row.targetId)) }" />
+          </template>
+        </el-table-column>
+        <el-table-column label="编号" prop="targetId" min-width="170" />
+        <el-table-column label="类型" width="80" align="center">
+          <template #default="{ row }">{{ pendingTargetLabel(row) }}</template>
+        </el-table-column>
+        <el-table-column label="数量" width="70" align="center">
+          <template #default="{ row }">{{ row.quantity }}</template>
+        </el-table-column>
+        <el-table-column label="区域" width="90" align="center">
+          <template #default="{ row }">{{ row.zoneCode || '未分区' }}</template>
+        </el-table-column>
+        <el-table-column label="操作" width="90" align="center" fixed="right">
+          <template #default="{ row }">
+            <el-button link type="success" size="small" @click="sendOneFromDrawer(row)">送检</el-button>
+          </template>
+        </el-table-column>
+      </el-table>
+      <div v-if="detailDrawer.total > detailDrawer.size" class="pager" style="margin-top:12px">
+        <el-pagination background layout="total, prev, pager, next"
+                       :total="detailDrawer.total" :current-page="detailDrawer.page"
+                       :page-size="detailDrawer.size"
+                       @current-change="changeDetailDrawerPage" />
+        <span style="margin-left:12px;color:#909399;font-size:12px">共 {{ detailDrawer.total }} 条，已加载 {{ detailDrawer.list.length }} / 页 {{ detailDrawer.page }}</span>
+      </div>
+      <div v-if="detailDrawer.total > 0" style="margin-top:12px;display:flex;gap:12px;align-items:center">
+        <el-button type="primary" :disabled="!detailDrawer.selected.length" @click="sendSelectedFromDrawer">
+          批量送检 ({{ detailDrawer.selected.length }})<span v-if="detailDrawer.selected.length>100" style="color:#f56c6c"> 上限 100</span>
+        </el-button>
+        <el-button type="success" plain @click="sendWhole(detailDrawer.row)">整单送检（全部 {{ detailDrawer.total }} 条）</el-button>
+      </div>
+    </el-drawer>
+
     <!-- 不合格处置弹窗 -->
     <el-dialog v-model="disposeDialog.visible" title="不合格品处置" width="480px">
       <el-form label-width="96px">
diff --git a/bj_power_wms/frontend/src/pages/Outbound.vue b/bj_power_wms/frontend/src/pages/Outbound.vue
index 4564dca..456fe20 100644
--- a/bj_power_wms/frontend/src/pages/Outbound.vue
+++ b/bj_power_wms/frontend/src/pages/Outbound.vue
@@ -131,10 +131,12 @@ const batchOptions = ref([])
 // 选中物料的展示类型（问题18：类型含「其他」）：other=其他品类(按批次管理)/sn=电气件/batch=结构件
 const pickedType = ref('')
 const genForm = reactive({
+  outboundNo: '',
   materialCode: '', mode: 1, batchNo: '', qty: 1, zoneCode: '',
   shelfNo: '', layerNo: '', positionNo: '',
   boxNo: '', contractNo: '', remark: '',
-  outboundCategory: 'other', ownershipType: 'other', ownershipNo: '', targetStation: ''
+  outboundCategory: 'other', ownershipType: 'other', ownershipNo: '', targetStation: '',
+  inspectionNo: ''
 })
 const snInput = ref('')
 const snList = ref([])
@@ -297,8 +299,10 @@ async function submitGen() {
     ElMessage.warning('出库类别选「其他」时，请在备注中填写具体原因'); return
   }
   const payload = {
+    outboundNo: genForm.outboundNo.trim() || undefined,
     materialCode: genForm.materialCode, operator,
     outboundCategory: genForm.outboundCategory,
+    batchNo: batchVal,
     ownershipType: genForm.ownershipType,
     ownershipNo: genForm.ownershipNo.trim() || undefined,
     targetStation: genForm.targetStation.trim() || undefined,
@@ -308,7 +312,8 @@ async function submitGen() {
     positionNo: genForm.positionNo || undefined,
     boxNo: genForm.boxNo.trim() || undefined,
     contractNo: genForm.contractNo.trim() || undefined,
-    remark: genForm.remark.trim() || undefined
+    remark: genForm.remark.trim() || undefined,
+    inspectionNo: genForm.inspectionNo.trim() || undefined
   }
   if (genForm.mode === 1) {
     if (!genForm.batchNo) { ElMessage.warning('请从该物料可用批次中选择出库批次'); return }
@@ -345,7 +350,7 @@ function recDefaultRange() {
   const end = new Date(); const start = new Date(); start.setMonth(start.getMonth() - 3)
   return [fmt(start), fmt(end)]
 }
-const recFilters = reactive({ outboundType: '', status: '', materialCode: '', boxNo: '', ownershipNo: '', dateRange: recDefaultRange() })
+const recFilters = reactive({ outboundType: '', status: '', materialCode: '', boxNo: '', ownershipNo: '', inspectionNo: '', dateRange: recDefaultRange() })
 const recRows = ref([])
 const recTotal = ref(0)
 const loadingRec = ref(false)
@@ -362,6 +367,7 @@ async function loadRecords() {
       materialCode: recFilters.materialCode.trim(),
       boxNo: recFilters.boxNo.trim(),
       ownershipNo: recFilters.ownershipNo.trim(),
+      inspectionNo: recFilters.inspectionNo.trim(),
       page: recPage.current, pageSize: recPage.size
     }
     if (Array.isArray(recFilters.dateRange) && recFilters.dateRange.length === 2) {
@@ -385,6 +391,7 @@ function downloadCSV() {
     materialCode: recFilters.materialCode.trim(),
     boxNo: recFilters.boxNo.trim(),
     ownershipNo: recFilters.ownershipNo.trim(),
+    inspectionNo: recFilters.inspectionNo.trim(),
     startDate: dr[0],
     endDate: dr[1]
   }, '出库管理.xlsx', { countUrl: '/outbound/query', name: '出库记录' })
@@ -482,11 +489,18 @@ onMounted(loadDicts)
               <span v-else style="color:#909399;font-size:12px">请先选择物料，系统自动带出类型（电气件/结构件）</span>
             </el-form-item>
 
+            <el-form-item label="出库单号">
+              <el-input v-model="genForm.outboundNo" placeholder="留空自动生成（如 OB20260921-001）" clearable style="width:100%" />
+            </el-form-item>
+
             <el-form-item label="出库类别" required>
               <el-select v-model="genForm.outboundCategory" style="width:100%">
                 <el-option v-for="c in CATEGORY_OPTIONS" :key="c.value" :value="c.value" :label="c.label" />
               </el-select>
             </el-form-item>
+            <el-form-item label="检测单号">
+              <el-input v-model="genForm.inspectionNo" placeholder="退货/报废需溯源检验单据时填写（选填）" clearable style="width:100%" />
+            </el-form-item>
             <el-form-item label="归属">
               <el-select v-model="genForm.ownershipType" style="width:160px;margin-right:8px">
                 <el-option v-for="o in OWNERSHIP_OPTIONS" :key="o.value" :value="o.value" :label="o.label" />
@@ -642,6 +656,9 @@ onMounted(loadDicts)
             <el-form-item label="归属单号">
               <el-input v-model="recFilters.ownershipNo" placeholder="工单号/科技项目号" clearable style="width:160px" @keyup.enter="searchRec" />
             </el-form-item>
+            <el-form-item label="检测单号">
+              <el-input v-model="recFilters.inspectionNo" placeholder="检测单号(模糊)" clearable style="width:180px" @keyup.enter="searchRec" />
+            </el-form-item>
             <el-form-item label="时间">
               <el-date-picker v-model="recFilters.dateRange" type="daterange" value-format="YYYY-MM-DD"
                               range-separator="至" start-placeholder="开始" end-placeholder="结束" style="width:240px" />
diff --git a/bj_power_wms/go.sum b/bj_power_wms/go.sum
index 54c3357..d9f01fe 100644
--- a/bj_power_wms/go.sum
+++ b/bj_power_wms/go.sum
@@ -84,6 +84,7 @@ github.com/hashicorp/go-multierror v1.1.1/go.mod h1:iw975J/qwKPdAO1clOe2L8331t/9
 github.com/hashicorp/go-uuid v1.0.3/go.mod h1:6SBZvOh/SIDV7/2o3Jml5SYk/TvGqwFJ/bN7x4byOro=
 github.com/hashicorp/hcl/v2 v2.18.1 h1:6nxnOJFku1EuSawSD81fuviYUV8DxFr3fp2dUi3ZYSo=
 github.com/hashicorp/hcl/v2 v2.18.1/go.mod h1:ThLC89FV4p9MPW804KVbe/cEXoQ8NZEh+JtMeeGErHE=
+github.com/inconshreveable/mousetrap v1.1.0 h1:wN+x4NVGpMsO7ErUn/mUI3vEoE6Jt13X2s0bqwp9tc8=
 github.com/inconshreveable/mousetrap v1.1.0/go.mod h1:vpF70FUmC8bwa3OWnCshd2FqLfsEA9PFc4w1p2J65bw=
 github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
 github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
@@ -120,6 +121,7 @@ github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovk
 github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
 github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
 github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.17 h1:mCRHCLDUBXgpKAqIKsaAaAsrAlbkeomtRFKXh2L6YIM=
 github.com/mattn/go-sqlite3 v1.14.17/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
@@ -133,6 +135,7 @@ github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq
 github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
 github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
+github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
 github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
 github.com/onsi/ginkgo/v2 v2.11.0/go.mod h1:ZhrRA5XmEE3x3rhlzamx/JJvujdZoJ2uvgI7kR0iZvM=
 github.com/onsi/gomega v1.27.10/go.mod h1:RsS8tutOdbdgzbPtzzATp12yT7kM5I5aElG3evPbQ0M=
@@ -160,6 +163,7 @@ github.com/richardlehane/mscfb v1.0.7 h1:oeoiM0WE79vHwE8RpIYYvIAc8ajTH2mb6UZm55/
 github.com/richardlehane/mscfb v1.0.7/go.mod h1:pe0+IUIc0AHh0+teNzBlJCtSyZdFOGgV4ZK9bsoV+Jo=
 github.com/richardlehane/msoleps v1.0.6 h1:9BvkpjvD+iUBalUY4esMwv6uBkfOip/Lzvd93jvR9gg=
 github.com/richardlehane/msoleps v1.0.6/go.mod h1:BWev5JBpU9Ko2WAgmZEuiz4/u3ZYTKbjLycmwiWUfWg=
+github.com/rivo/uniseg v0.2.0 h1:S1pD9weZBuJdFmowNwbpi7BJ8TNftyUImj/0WQi72jY=
 github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
 github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
 github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
@@ -168,7 +172,9 @@ github.com/sergi/go-diff v1.3.1 h1:xkr+Oxo4BOQKmkn/B9eMK0g5Kg/983T9DqqPHwYqD+8=
 github.com/sergi/go-diff v1.3.1/go.mod h1:aMJSSKb2lpPvRNec0+w3fl7LP9IOFzdc9Pa4NFbPK1I=
 github.com/spaolacci/murmur3 v1.1.0 h1:7c1g84S4BPRrfL5Xrdp6fOJ206sU9y293DDHaoy0bLI=
 github.com/spaolacci/murmur3 v1.1.0/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I=
 github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
diff --git a/bj_power_wms/hook/hook.go b/bj_power_wms/hook/hook.go
new file mode 100644
index 0000000..a470644
--- /dev/null
+++ b/bj_power_wms/hook/hook.go
@@ -0,0 +1,438 @@
+// Code generated by ent, DO NOT EDIT.
+
+package hook
+
+import (
+	"bj_power_wms"
+	"context"
+	"fmt"
+)
+
+// The AgvTaskFunc type is an adapter to allow the use of ordinary
+// function as AgvTask mutator.
+type AgvTaskFunc func(context.Context, *bj_power_wms.AgvTaskMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f AgvTaskFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.AgvTaskMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.AgvTaskMutation", m)
+}
+
+// The AttachmentFunc type is an adapter to allow the use of ordinary
+// function as Attachment mutator.
+type AttachmentFunc func(context.Context, *bj_power_wms.AttachmentMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f AttachmentFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.AttachmentMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.AttachmentMutation", m)
+}
+
+// The EventLogFunc type is an adapter to allow the use of ordinary
+// function as EventLog mutator.
+type EventLogFunc func(context.Context, *bj_power_wms.EventLogMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f EventLogFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.EventLogMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.EventLogMutation", m)
+}
+
+// The InboundDetailFunc type is an adapter to allow the use of ordinary
+// function as InboundDetail mutator.
+type InboundDetailFunc func(context.Context, *bj_power_wms.InboundDetailMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f InboundDetailFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.InboundDetailMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.InboundDetailMutation", m)
+}
+
+// The InboundOrderFunc type is an adapter to allow the use of ordinary
+// function as InboundOrder mutator.
+type InboundOrderFunc func(context.Context, *bj_power_wms.InboundOrderMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f InboundOrderFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.InboundOrderMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.InboundOrderMutation", m)
+}
+
+// The InspectionRecordFunc type is an adapter to allow the use of ordinary
+// function as InspectionRecord mutator.
+type InspectionRecordFunc func(context.Context, *bj_power_wms.InspectionRecordMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f InspectionRecordFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.InspectionRecordMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.InspectionRecordMutation", m)
+}
+
+// The InventoryFunc type is an adapter to allow the use of ordinary
+// function as Inventory mutator.
+type InventoryFunc func(context.Context, *bj_power_wms.InventoryMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f InventoryFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.InventoryMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.InventoryMutation", m)
+}
+
+// The InventoryLockFunc type is an adapter to allow the use of ordinary
+// function as InventoryLock mutator.
+type InventoryLockFunc func(context.Context, *bj_power_wms.InventoryLockMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f InventoryLockFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.InventoryLockMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.InventoryLockMutation", m)
+}
+
+// The MaterialFunc type is an adapter to allow the use of ordinary
+// function as Material mutator.
+type MaterialFunc func(context.Context, *bj_power_wms.MaterialMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f MaterialFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.MaterialMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.MaterialMutation", m)
+}
+
+// The MaterialDemandFunc type is an adapter to allow the use of ordinary
+// function as MaterialDemand mutator.
+type MaterialDemandFunc func(context.Context, *bj_power_wms.MaterialDemandMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f MaterialDemandFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.MaterialDemandMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.MaterialDemandMutation", m)
+}
+
+// The OrderMaterialLedgerFunc type is an adapter to allow the use of ordinary
+// function as OrderMaterialLedger mutator.
+type OrderMaterialLedgerFunc func(context.Context, *bj_power_wms.OrderMaterialLedgerMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f OrderMaterialLedgerFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.OrderMaterialLedgerMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.OrderMaterialLedgerMutation", m)
+}
+
+// The OutboundDetailFunc type is an adapter to allow the use of ordinary
+// function as OutboundDetail mutator.
+type OutboundDetailFunc func(context.Context, *bj_power_wms.OutboundDetailMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f OutboundDetailFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.OutboundDetailMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.OutboundDetailMutation", m)
+}
+
+// The OutboundOrderFunc type is an adapter to allow the use of ordinary
+// function as OutboundOrder mutator.
+type OutboundOrderFunc func(context.Context, *bj_power_wms.OutboundOrderMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f OutboundOrderFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.OutboundOrderMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.OutboundOrderMutation", m)
+}
+
+// The PermissionFunc type is an adapter to allow the use of ordinary
+// function as Permission mutator.
+type PermissionFunc func(context.Context, *bj_power_wms.PermissionMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f PermissionFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.PermissionMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.PermissionMutation", m)
+}
+
+// The ReturnOrderFunc type is an adapter to allow the use of ordinary
+// function as ReturnOrder mutator.
+type ReturnOrderFunc func(context.Context, *bj_power_wms.ReturnOrderMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ReturnOrderFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.ReturnOrderMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.ReturnOrderMutation", m)
+}
+
+// The RoleFunc type is an adapter to allow the use of ordinary
+// function as Role mutator.
+type RoleFunc func(context.Context, *bj_power_wms.RoleMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f RoleFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.RoleMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.RoleMutation", m)
+}
+
+// The SemiFinishedFunc type is an adapter to allow the use of ordinary
+// function as SemiFinished mutator.
+type SemiFinishedFunc func(context.Context, *bj_power_wms.SemiFinishedMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f SemiFinishedFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.SemiFinishedMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.SemiFinishedMutation", m)
+}
+
+// The StocktakeItemFunc type is an adapter to allow the use of ordinary
+// function as StocktakeItem mutator.
+type StocktakeItemFunc func(context.Context, *bj_power_wms.StocktakeItemMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f StocktakeItemFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.StocktakeItemMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.StocktakeItemMutation", m)
+}
+
+// The StocktakeOrderFunc type is an adapter to allow the use of ordinary
+// function as StocktakeOrder mutator.
+type StocktakeOrderFunc func(context.Context, *bj_power_wms.StocktakeOrderMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f StocktakeOrderFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.StocktakeOrderMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.StocktakeOrderMutation", m)
+}
+
+// The UserFunc type is an adapter to allow the use of ordinary
+// function as User mutator.
+type UserFunc func(context.Context, *bj_power_wms.UserMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f UserFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.UserMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.UserMutation", m)
+}
+
+// The ZoneFunc type is an adapter to allow the use of ordinary
+// function as Zone mutator.
+type ZoneFunc func(context.Context, *bj_power_wms.ZoneMutation) (bj_power_wms.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f ZoneFunc) Mutate(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+	if mv, ok := m.(*bj_power_wms.ZoneMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *bj_power_wms.ZoneMutation", m)
+}
+
+// Condition is a hook condition function.
+type Condition func(context.Context, bj_power_wms.Mutation) bool
+
+// And groups conditions with the AND operator.
+func And(first, second Condition, rest ...Condition) Condition {
+	return func(ctx context.Context, m bj_power_wms.Mutation) bool {
+		if !first(ctx, m) || !second(ctx, m) {
+			return false
+		}
+		for _, cond := range rest {
+			if !cond(ctx, m) {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// Or groups conditions with the OR operator.
+func Or(first, second Condition, rest ...Condition) Condition {
+	return func(ctx context.Context, m bj_power_wms.Mutation) bool {
+		if first(ctx, m) || second(ctx, m) {
+			return true
+		}
+		for _, cond := range rest {
+			if cond(ctx, m) {
+				return true
+			}
+		}
+		return false
+	}
+}
+
+// Not negates a given condition.
+func Not(cond Condition) Condition {
+	return func(ctx context.Context, m bj_power_wms.Mutation) bool {
+		return !cond(ctx, m)
+	}
+}
+
+// HasOp is a condition testing mutation operation.
+func HasOp(op bj_power_wms.Op) Condition {
+	return func(_ context.Context, m bj_power_wms.Mutation) bool {
+		return m.Op().Is(op)
+	}
+}
+
+// HasAddedFields is a condition validating `.AddedField` on fields.
+func HasAddedFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m bj_power_wms.Mutation) bool {
+		if _, exists := m.AddedField(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if _, exists := m.AddedField(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// HasClearedFields is a condition validating `.FieldCleared` on fields.
+func HasClearedFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m bj_power_wms.Mutation) bool {
+		if exists := m.FieldCleared(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if exists := m.FieldCleared(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// HasFields is a condition validating `.Field` on fields.
+func HasFields(field string, fields ...string) Condition {
+	return func(_ context.Context, m bj_power_wms.Mutation) bool {
+		if _, exists := m.Field(field); !exists {
+			return false
+		}
+		for _, field := range fields {
+			if _, exists := m.Field(field); !exists {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// If executes the given hook under condition.
+//
+//	hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...)))
+func If(hk bj_power_wms.Hook, cond Condition) bj_power_wms.Hook {
+	return func(next bj_power_wms.Mutator) bj_power_wms.Mutator {
+		return bj_power_wms.MutateFunc(func(ctx context.Context, m bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+			if cond(ctx, m) {
+				return hk(next).Mutate(ctx, m)
+			}
+			return next.Mutate(ctx, m)
+		})
+	}
+}
+
+// On executes the given hook only for the given operation.
+//
+//	hook.On(Log, bj_power_wms.Delete|bj_power_wms.Create)
+func On(hk bj_power_wms.Hook, op bj_power_wms.Op) bj_power_wms.Hook {
+	return If(hk, HasOp(op))
+}
+
+// Unless skips the given hook only for the given operation.
+//
+//	hook.Unless(Log, bj_power_wms.Update|bj_power_wms.UpdateOne)
+func Unless(hk bj_power_wms.Hook, op bj_power_wms.Op) bj_power_wms.Hook {
+	return If(hk, Not(HasOp(op)))
+}
+
+// FixedError is a hook returning a fixed error.
+func FixedError(err error) bj_power_wms.Hook {
+	return func(bj_power_wms.Mutator) bj_power_wms.Mutator {
+		return bj_power_wms.MutateFunc(func(context.Context, bj_power_wms.Mutation) (bj_power_wms.Value, error) {
+			return nil, err
+		})
+	}
+}
+
+// Reject returns a hook that rejects all operations that match op.
+//
+//	func (T) Hooks() []bj_power_wms.Hook {
+//		return []bj_power_wms.Hook{
+//			Reject(bj_power_wms.Delete|bj_power_wms.Update),
+//		}
+//	}
+func Reject(op bj_power_wms.Op) bj_power_wms.Hook {
+	hk := FixedError(fmt.Errorf("%s operation is not allowed", op))
+	return On(hk, op)
+}
+
+// Chain acts as a list of hooks and is effectively immutable.
+// Once created, it will always hold the same set of hooks in the same order.
+type Chain struct {
+	hooks []bj_power_wms.Hook
+}
+
+// NewChain creates a new chain of hooks.
+func NewChain(hooks ...bj_power_wms.Hook) Chain {
+	return Chain{append([]bj_power_wms.Hook(nil), hooks...)}
+}
+
+// Hook chains the list of hooks and returns the final hook.
+func (c Chain) Hook() bj_power_wms.Hook {
+	return func(mutator bj_power_wms.Mutator) bj_power_wms.Mutator {
+		for i := len(c.hooks) - 1; i >= 0; i-- {
+			mutator = c.hooks[i](mutator)
+		}
+		return mutator
+	}
+}
+
+// Append extends a chain, adding the specified hook
+// as the last ones in the mutation flow.
+func (c Chain) Append(hooks ...bj_power_wms.Hook) Chain {
+	newHooks := make([]bj_power_wms.Hook, 0, len(c.hooks)+len(hooks))
+	newHooks = append(newHooks, c.hooks...)
+	newHooks = append(newHooks, hooks...)
+	return Chain{newHooks}
+}
+
+// Extend extends a chain, adding the specified chain
+// as the last ones in the mutation flow.
+func (c Chain) Extend(chain Chain) Chain {
+	return c.Append(chain.hooks...)
+}
diff --git a/bj_power_wms/inbounddetail/inbounddetail.go b/bj_power_wms/inbounddetail/inbounddetail.go
new file mode 100644
index 0000000..bcd1099
--- /dev/null
+++ b/bj_power_wms/inbounddetail/inbounddetail.go
@@ -0,0 +1,94 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inbounddetail
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the inbounddetail type in the database.
+	Label = "inbound_detail"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldInboundNo holds the string denoting the inbound_no field in the database.
+	FieldInboundNo = "inbound_no"
+	// FieldSnCode holds the string denoting the sn_code field in the database.
+	FieldSnCode = "sn_code"
+	// FieldBatchNo holds the string denoting the batch_no field in the database.
+	FieldBatchNo = "batch_no"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldQuantity holds the string denoting the quantity field in the database.
+	FieldQuantity = "quantity"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// Table holds the table name of the inbounddetail in the database.
+	Table = "inbound_details"
+)
+
+// Columns holds all SQL columns for inbounddetail fields.
+var Columns = []string{
+	FieldID,
+	FieldInboundNo,
+	FieldSnCode,
+	FieldBatchNo,
+	FieldMaterialCode,
+	FieldQuantity,
+	FieldCreatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultQuantity holds the default value on creation for the "quantity" field.
+	DefaultQuantity int
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the InboundDetail queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByInboundNo orders the results by the inbound_no field.
+func ByInboundNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInboundNo, opts...).ToFunc()
+}
+
+// BySnCode orders the results by the sn_code field.
+func BySnCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSnCode, opts...).ToFunc()
+}
+
+// ByBatchNo orders the results by the batch_no field.
+func ByBatchNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBatchNo, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByQuantity orders the results by the quantity field.
+func ByQuantity(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQuantity, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/inbounddetail/where.go b/bj_power_wms/inbounddetail/where.go
new file mode 100644
index 0000000..2ef2e78
--- /dev/null
+++ b/bj_power_wms/inbounddetail/where.go
@@ -0,0 +1,459 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inbounddetail
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLTE(FieldID, id))
+}
+
+// InboundNo applies equality check predicate on the "inbound_no" field. It's identical to InboundNoEQ.
+func InboundNo(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldInboundNo, v))
+}
+
+// SnCode applies equality check predicate on the "sn_code" field. It's identical to SnCodeEQ.
+func SnCode(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldSnCode, v))
+}
+
+// BatchNo applies equality check predicate on the "batch_no" field. It's identical to BatchNoEQ.
+func BatchNo(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// Quantity applies equality check predicate on the "quantity" field. It's identical to QuantityEQ.
+func Quantity(v int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldQuantity, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// InboundNoEQ applies the EQ predicate on the "inbound_no" field.
+func InboundNoEQ(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldInboundNo, v))
+}
+
+// InboundNoNEQ applies the NEQ predicate on the "inbound_no" field.
+func InboundNoNEQ(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNEQ(FieldInboundNo, v))
+}
+
+// InboundNoIn applies the In predicate on the "inbound_no" field.
+func InboundNoIn(vs ...string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIn(FieldInboundNo, vs...))
+}
+
+// InboundNoNotIn applies the NotIn predicate on the "inbound_no" field.
+func InboundNoNotIn(vs ...string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotIn(FieldInboundNo, vs...))
+}
+
+// InboundNoGT applies the GT predicate on the "inbound_no" field.
+func InboundNoGT(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGT(FieldInboundNo, v))
+}
+
+// InboundNoGTE applies the GTE predicate on the "inbound_no" field.
+func InboundNoGTE(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGTE(FieldInboundNo, v))
+}
+
+// InboundNoLT applies the LT predicate on the "inbound_no" field.
+func InboundNoLT(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLT(FieldInboundNo, v))
+}
+
+// InboundNoLTE applies the LTE predicate on the "inbound_no" field.
+func InboundNoLTE(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLTE(FieldInboundNo, v))
+}
+
+// InboundNoContains applies the Contains predicate on the "inbound_no" field.
+func InboundNoContains(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldContains(FieldInboundNo, v))
+}
+
+// InboundNoHasPrefix applies the HasPrefix predicate on the "inbound_no" field.
+func InboundNoHasPrefix(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldHasPrefix(FieldInboundNo, v))
+}
+
+// InboundNoHasSuffix applies the HasSuffix predicate on the "inbound_no" field.
+func InboundNoHasSuffix(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldHasSuffix(FieldInboundNo, v))
+}
+
+// InboundNoEqualFold applies the EqualFold predicate on the "inbound_no" field.
+func InboundNoEqualFold(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEqualFold(FieldInboundNo, v))
+}
+
+// InboundNoContainsFold applies the ContainsFold predicate on the "inbound_no" field.
+func InboundNoContainsFold(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldContainsFold(FieldInboundNo, v))
+}
+
+// SnCodeEQ applies the EQ predicate on the "sn_code" field.
+func SnCodeEQ(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldSnCode, v))
+}
+
+// SnCodeNEQ applies the NEQ predicate on the "sn_code" field.
+func SnCodeNEQ(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNEQ(FieldSnCode, v))
+}
+
+// SnCodeIn applies the In predicate on the "sn_code" field.
+func SnCodeIn(vs ...string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIn(FieldSnCode, vs...))
+}
+
+// SnCodeNotIn applies the NotIn predicate on the "sn_code" field.
+func SnCodeNotIn(vs ...string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotIn(FieldSnCode, vs...))
+}
+
+// SnCodeGT applies the GT predicate on the "sn_code" field.
+func SnCodeGT(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGT(FieldSnCode, v))
+}
+
+// SnCodeGTE applies the GTE predicate on the "sn_code" field.
+func SnCodeGTE(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGTE(FieldSnCode, v))
+}
+
+// SnCodeLT applies the LT predicate on the "sn_code" field.
+func SnCodeLT(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLT(FieldSnCode, v))
+}
+
+// SnCodeLTE applies the LTE predicate on the "sn_code" field.
+func SnCodeLTE(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLTE(FieldSnCode, v))
+}
+
+// SnCodeContains applies the Contains predicate on the "sn_code" field.
+func SnCodeContains(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldContains(FieldSnCode, v))
+}
+
+// SnCodeHasPrefix applies the HasPrefix predicate on the "sn_code" field.
+func SnCodeHasPrefix(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldHasPrefix(FieldSnCode, v))
+}
+
+// SnCodeHasSuffix applies the HasSuffix predicate on the "sn_code" field.
+func SnCodeHasSuffix(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldHasSuffix(FieldSnCode, v))
+}
+
+// SnCodeIsNil applies the IsNil predicate on the "sn_code" field.
+func SnCodeIsNil() predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIsNull(FieldSnCode))
+}
+
+// SnCodeNotNil applies the NotNil predicate on the "sn_code" field.
+func SnCodeNotNil() predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotNull(FieldSnCode))
+}
+
+// SnCodeEqualFold applies the EqualFold predicate on the "sn_code" field.
+func SnCodeEqualFold(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEqualFold(FieldSnCode, v))
+}
+
+// SnCodeContainsFold applies the ContainsFold predicate on the "sn_code" field.
+func SnCodeContainsFold(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldContainsFold(FieldSnCode, v))
+}
+
+// BatchNoEQ applies the EQ predicate on the "batch_no" field.
+func BatchNoEQ(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// BatchNoNEQ applies the NEQ predicate on the "batch_no" field.
+func BatchNoNEQ(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNEQ(FieldBatchNo, v))
+}
+
+// BatchNoIn applies the In predicate on the "batch_no" field.
+func BatchNoIn(vs ...string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIn(FieldBatchNo, vs...))
+}
+
+// BatchNoNotIn applies the NotIn predicate on the "batch_no" field.
+func BatchNoNotIn(vs ...string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotIn(FieldBatchNo, vs...))
+}
+
+// BatchNoGT applies the GT predicate on the "batch_no" field.
+func BatchNoGT(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGT(FieldBatchNo, v))
+}
+
+// BatchNoGTE applies the GTE predicate on the "batch_no" field.
+func BatchNoGTE(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGTE(FieldBatchNo, v))
+}
+
+// BatchNoLT applies the LT predicate on the "batch_no" field.
+func BatchNoLT(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLT(FieldBatchNo, v))
+}
+
+// BatchNoLTE applies the LTE predicate on the "batch_no" field.
+func BatchNoLTE(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLTE(FieldBatchNo, v))
+}
+
+// BatchNoContains applies the Contains predicate on the "batch_no" field.
+func BatchNoContains(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldContains(FieldBatchNo, v))
+}
+
+// BatchNoHasPrefix applies the HasPrefix predicate on the "batch_no" field.
+func BatchNoHasPrefix(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldHasPrefix(FieldBatchNo, v))
+}
+
+// BatchNoHasSuffix applies the HasSuffix predicate on the "batch_no" field.
+func BatchNoHasSuffix(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldHasSuffix(FieldBatchNo, v))
+}
+
+// BatchNoIsNil applies the IsNil predicate on the "batch_no" field.
+func BatchNoIsNil() predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIsNull(FieldBatchNo))
+}
+
+// BatchNoNotNil applies the NotNil predicate on the "batch_no" field.
+func BatchNoNotNil() predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotNull(FieldBatchNo))
+}
+
+// BatchNoEqualFold applies the EqualFold predicate on the "batch_no" field.
+func BatchNoEqualFold(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEqualFold(FieldBatchNo, v))
+}
+
+// BatchNoContainsFold applies the ContainsFold predicate on the "batch_no" field.
+func BatchNoContainsFold(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldContainsFold(FieldBatchNo, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// QuantityEQ applies the EQ predicate on the "quantity" field.
+func QuantityEQ(v int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldQuantity, v))
+}
+
+// QuantityNEQ applies the NEQ predicate on the "quantity" field.
+func QuantityNEQ(v int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNEQ(FieldQuantity, v))
+}
+
+// QuantityIn applies the In predicate on the "quantity" field.
+func QuantityIn(vs ...int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIn(FieldQuantity, vs...))
+}
+
+// QuantityNotIn applies the NotIn predicate on the "quantity" field.
+func QuantityNotIn(vs ...int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotIn(FieldQuantity, vs...))
+}
+
+// QuantityGT applies the GT predicate on the "quantity" field.
+func QuantityGT(v int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGT(FieldQuantity, v))
+}
+
+// QuantityGTE applies the GTE predicate on the "quantity" field.
+func QuantityGTE(v int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGTE(FieldQuantity, v))
+}
+
+// QuantityLT applies the LT predicate on the "quantity" field.
+func QuantityLT(v int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLT(FieldQuantity, v))
+}
+
+// QuantityLTE applies the LTE predicate on the "quantity" field.
+func QuantityLTE(v int) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLTE(FieldQuantity, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.InboundDetail) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.InboundDetail) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.InboundDetail) predicate.InboundDetail {
+	return predicate.InboundDetail(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/inboundorder/inboundorder.go b/bj_power_wms/inboundorder/inboundorder.go
new file mode 100644
index 0000000..25f0dff
--- /dev/null
+++ b/bj_power_wms/inboundorder/inboundorder.go
@@ -0,0 +1,230 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inboundorder
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the inboundorder type in the database.
+	Label = "inbound_order"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldInboundNo holds the string denoting the inbound_no field in the database.
+	FieldInboundNo = "inbound_no"
+	// FieldInboundType holds the string denoting the inbound_type field in the database.
+	FieldInboundType = "inbound_type"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldMaterialName holds the string denoting the material_name field in the database.
+	FieldMaterialName = "material_name"
+	// FieldManageMode holds the string denoting the manage_mode field in the database.
+	FieldManageMode = "manage_mode"
+	// FieldBatchNo holds the string denoting the batch_no field in the database.
+	FieldBatchNo = "batch_no"
+	// FieldZoneCode holds the string denoting the zone_code field in the database.
+	FieldZoneCode = "zone_code"
+	// FieldShelfNo holds the string denoting the shelf_no field in the database.
+	FieldShelfNo = "shelf_no"
+	// FieldLayerNo holds the string denoting the layer_no field in the database.
+	FieldLayerNo = "layer_no"
+	// FieldPositionNo holds the string denoting the position_no field in the database.
+	FieldPositionNo = "position_no"
+	// FieldQuantity holds the string denoting the quantity field in the database.
+	FieldQuantity = "quantity"
+	// FieldOperator holds the string denoting the operator field in the database.
+	FieldOperator = "operator"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldInspectionNo holds the string denoting the inspection_no field in the database.
+	FieldInspectionNo = "inspection_no"
+	// FieldOwnershipType holds the string denoting the ownership_type field in the database.
+	FieldOwnershipType = "ownership_type"
+	// FieldOwnershipNo holds the string denoting the ownership_no field in the database.
+	FieldOwnershipNo = "ownership_no"
+	// FieldQualityStatus holds the string denoting the quality_status field in the database.
+	FieldQualityStatus = "quality_status"
+	// FieldVoided holds the string denoting the voided field in the database.
+	FieldVoided = "voided"
+	// FieldVoidReason holds the string denoting the void_reason field in the database.
+	FieldVoidReason = "void_reason"
+	// FieldVoidedBy holds the string denoting the voided_by field in the database.
+	FieldVoidedBy = "voided_by"
+	// FieldVoidedAt holds the string denoting the voided_at field in the database.
+	FieldVoidedAt = "voided_at"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// Table holds the table name of the inboundorder in the database.
+	Table = "inbound_orders"
+)
+
+// Columns holds all SQL columns for inboundorder fields.
+var Columns = []string{
+	FieldID,
+	FieldInboundNo,
+	FieldInboundType,
+	FieldMaterialCode,
+	FieldMaterialName,
+	FieldManageMode,
+	FieldBatchNo,
+	FieldZoneCode,
+	FieldShelfNo,
+	FieldLayerNo,
+	FieldPositionNo,
+	FieldQuantity,
+	FieldOperator,
+	FieldRemark,
+	FieldInspectionNo,
+	FieldOwnershipType,
+	FieldOwnershipNo,
+	FieldQualityStatus,
+	FieldVoided,
+	FieldVoidReason,
+	FieldVoidedBy,
+	FieldVoidedAt,
+	FieldCreatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultInboundType holds the default value on creation for the "inbound_type" field.
+	DefaultInboundType string
+	// DefaultManageMode holds the default value on creation for the "manage_mode" field.
+	DefaultManageMode int
+	// DefaultQuantity holds the default value on creation for the "quantity" field.
+	DefaultQuantity int
+	// DefaultOwnershipType holds the default value on creation for the "ownership_type" field.
+	DefaultOwnershipType string
+	// DefaultVoided holds the default value on creation for the "voided" field.
+	DefaultVoided bool
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the InboundOrder queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByInboundNo orders the results by the inbound_no field.
+func ByInboundNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInboundNo, opts...).ToFunc()
+}
+
+// ByInboundType orders the results by the inbound_type field.
+func ByInboundType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInboundType, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByMaterialName orders the results by the material_name field.
+func ByMaterialName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialName, opts...).ToFunc()
+}
+
+// ByManageMode orders the results by the manage_mode field.
+func ByManageMode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldManageMode, opts...).ToFunc()
+}
+
+// ByBatchNo orders the results by the batch_no field.
+func ByBatchNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBatchNo, opts...).ToFunc()
+}
+
+// ByZoneCode orders the results by the zone_code field.
+func ByZoneCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldZoneCode, opts...).ToFunc()
+}
+
+// ByShelfNo orders the results by the shelf_no field.
+func ByShelfNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldShelfNo, opts...).ToFunc()
+}
+
+// ByLayerNo orders the results by the layer_no field.
+func ByLayerNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLayerNo, opts...).ToFunc()
+}
+
+// ByPositionNo orders the results by the position_no field.
+func ByPositionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPositionNo, opts...).ToFunc()
+}
+
+// ByQuantity orders the results by the quantity field.
+func ByQuantity(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQuantity, opts...).ToFunc()
+}
+
+// ByOperator orders the results by the operator field.
+func ByOperator(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOperator, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByInspectionNo orders the results by the inspection_no field.
+func ByInspectionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInspectionNo, opts...).ToFunc()
+}
+
+// ByOwnershipType orders the results by the ownership_type field.
+func ByOwnershipType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOwnershipType, opts...).ToFunc()
+}
+
+// ByOwnershipNo orders the results by the ownership_no field.
+func ByOwnershipNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOwnershipNo, opts...).ToFunc()
+}
+
+// ByQualityStatus orders the results by the quality_status field.
+func ByQualityStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQualityStatus, opts...).ToFunc()
+}
+
+// ByVoided orders the results by the voided field.
+func ByVoided(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldVoided, opts...).ToFunc()
+}
+
+// ByVoidReason orders the results by the void_reason field.
+func ByVoidReason(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldVoidReason, opts...).ToFunc()
+}
+
+// ByVoidedBy orders the results by the voided_by field.
+func ByVoidedBy(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldVoidedBy, opts...).ToFunc()
+}
+
+// ByVoidedAt orders the results by the voided_at field.
+func ByVoidedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldVoidedAt, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/inboundorder/where.go b/bj_power_wms/inboundorder/where.go
new file mode 100644
index 0000000..bfc13dd
--- /dev/null
+++ b/bj_power_wms/inboundorder/where.go
@@ -0,0 +1,1584 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inboundorder
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldID, id))
+}
+
+// InboundNo applies equality check predicate on the "inbound_no" field. It's identical to InboundNoEQ.
+func InboundNo(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldInboundNo, v))
+}
+
+// InboundType applies equality check predicate on the "inbound_type" field. It's identical to InboundTypeEQ.
+func InboundType(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldInboundType, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialName applies equality check predicate on the "material_name" field. It's identical to MaterialNameEQ.
+func MaterialName(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// ManageMode applies equality check predicate on the "manage_mode" field. It's identical to ManageModeEQ.
+func ManageMode(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldManageMode, v))
+}
+
+// BatchNo applies equality check predicate on the "batch_no" field. It's identical to BatchNoEQ.
+func BatchNo(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// ZoneCode applies equality check predicate on the "zone_code" field. It's identical to ZoneCodeEQ.
+func ZoneCode(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ShelfNo applies equality check predicate on the "shelf_no" field. It's identical to ShelfNoEQ.
+func ShelfNo(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// LayerNo applies equality check predicate on the "layer_no" field. It's identical to LayerNoEQ.
+func LayerNo(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// PositionNo applies equality check predicate on the "position_no" field. It's identical to PositionNoEQ.
+func PositionNo(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// Quantity applies equality check predicate on the "quantity" field. It's identical to QuantityEQ.
+func Quantity(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldQuantity, v))
+}
+
+// Operator applies equality check predicate on the "operator" field. It's identical to OperatorEQ.
+func Operator(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldOperator, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldRemark, v))
+}
+
+// InspectionNo applies equality check predicate on the "inspection_no" field. It's identical to InspectionNoEQ.
+func InspectionNo(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldInspectionNo, v))
+}
+
+// OwnershipType applies equality check predicate on the "ownership_type" field. It's identical to OwnershipTypeEQ.
+func OwnershipType(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldOwnershipType, v))
+}
+
+// OwnershipNo applies equality check predicate on the "ownership_no" field. It's identical to OwnershipNoEQ.
+func OwnershipNo(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldOwnershipNo, v))
+}
+
+// QualityStatus applies equality check predicate on the "quality_status" field. It's identical to QualityStatusEQ.
+func QualityStatus(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldQualityStatus, v))
+}
+
+// Voided applies equality check predicate on the "voided" field. It's identical to VoidedEQ.
+func Voided(v bool) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldVoided, v))
+}
+
+// VoidReason applies equality check predicate on the "void_reason" field. It's identical to VoidReasonEQ.
+func VoidReason(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldVoidReason, v))
+}
+
+// VoidedBy applies equality check predicate on the "voided_by" field. It's identical to VoidedByEQ.
+func VoidedBy(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldVoidedBy, v))
+}
+
+// VoidedAt applies equality check predicate on the "voided_at" field. It's identical to VoidedAtEQ.
+func VoidedAt(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldVoidedAt, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// InboundNoEQ applies the EQ predicate on the "inbound_no" field.
+func InboundNoEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldInboundNo, v))
+}
+
+// InboundNoNEQ applies the NEQ predicate on the "inbound_no" field.
+func InboundNoNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldInboundNo, v))
+}
+
+// InboundNoIn applies the In predicate on the "inbound_no" field.
+func InboundNoIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldInboundNo, vs...))
+}
+
+// InboundNoNotIn applies the NotIn predicate on the "inbound_no" field.
+func InboundNoNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldInboundNo, vs...))
+}
+
+// InboundNoGT applies the GT predicate on the "inbound_no" field.
+func InboundNoGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldInboundNo, v))
+}
+
+// InboundNoGTE applies the GTE predicate on the "inbound_no" field.
+func InboundNoGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldInboundNo, v))
+}
+
+// InboundNoLT applies the LT predicate on the "inbound_no" field.
+func InboundNoLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldInboundNo, v))
+}
+
+// InboundNoLTE applies the LTE predicate on the "inbound_no" field.
+func InboundNoLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldInboundNo, v))
+}
+
+// InboundNoContains applies the Contains predicate on the "inbound_no" field.
+func InboundNoContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldInboundNo, v))
+}
+
+// InboundNoHasPrefix applies the HasPrefix predicate on the "inbound_no" field.
+func InboundNoHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldInboundNo, v))
+}
+
+// InboundNoHasSuffix applies the HasSuffix predicate on the "inbound_no" field.
+func InboundNoHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldInboundNo, v))
+}
+
+// InboundNoEqualFold applies the EqualFold predicate on the "inbound_no" field.
+func InboundNoEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldInboundNo, v))
+}
+
+// InboundNoContainsFold applies the ContainsFold predicate on the "inbound_no" field.
+func InboundNoContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldInboundNo, v))
+}
+
+// InboundTypeEQ applies the EQ predicate on the "inbound_type" field.
+func InboundTypeEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldInboundType, v))
+}
+
+// InboundTypeNEQ applies the NEQ predicate on the "inbound_type" field.
+func InboundTypeNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldInboundType, v))
+}
+
+// InboundTypeIn applies the In predicate on the "inbound_type" field.
+func InboundTypeIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldInboundType, vs...))
+}
+
+// InboundTypeNotIn applies the NotIn predicate on the "inbound_type" field.
+func InboundTypeNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldInboundType, vs...))
+}
+
+// InboundTypeGT applies the GT predicate on the "inbound_type" field.
+func InboundTypeGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldInboundType, v))
+}
+
+// InboundTypeGTE applies the GTE predicate on the "inbound_type" field.
+func InboundTypeGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldInboundType, v))
+}
+
+// InboundTypeLT applies the LT predicate on the "inbound_type" field.
+func InboundTypeLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldInboundType, v))
+}
+
+// InboundTypeLTE applies the LTE predicate on the "inbound_type" field.
+func InboundTypeLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldInboundType, v))
+}
+
+// InboundTypeContains applies the Contains predicate on the "inbound_type" field.
+func InboundTypeContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldInboundType, v))
+}
+
+// InboundTypeHasPrefix applies the HasPrefix predicate on the "inbound_type" field.
+func InboundTypeHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldInboundType, v))
+}
+
+// InboundTypeHasSuffix applies the HasSuffix predicate on the "inbound_type" field.
+func InboundTypeHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldInboundType, v))
+}
+
+// InboundTypeEqualFold applies the EqualFold predicate on the "inbound_type" field.
+func InboundTypeEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldInboundType, v))
+}
+
+// InboundTypeContainsFold applies the ContainsFold predicate on the "inbound_type" field.
+func InboundTypeContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldInboundType, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// MaterialNameEQ applies the EQ predicate on the "material_name" field.
+func MaterialNameEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// MaterialNameNEQ applies the NEQ predicate on the "material_name" field.
+func MaterialNameNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldMaterialName, v))
+}
+
+// MaterialNameIn applies the In predicate on the "material_name" field.
+func MaterialNameIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameNotIn applies the NotIn predicate on the "material_name" field.
+func MaterialNameNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameGT applies the GT predicate on the "material_name" field.
+func MaterialNameGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldMaterialName, v))
+}
+
+// MaterialNameGTE applies the GTE predicate on the "material_name" field.
+func MaterialNameGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldMaterialName, v))
+}
+
+// MaterialNameLT applies the LT predicate on the "material_name" field.
+func MaterialNameLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldMaterialName, v))
+}
+
+// MaterialNameLTE applies the LTE predicate on the "material_name" field.
+func MaterialNameLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldMaterialName, v))
+}
+
+// MaterialNameContains applies the Contains predicate on the "material_name" field.
+func MaterialNameContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldMaterialName, v))
+}
+
+// MaterialNameHasPrefix applies the HasPrefix predicate on the "material_name" field.
+func MaterialNameHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldMaterialName, v))
+}
+
+// MaterialNameHasSuffix applies the HasSuffix predicate on the "material_name" field.
+func MaterialNameHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldMaterialName, v))
+}
+
+// MaterialNameIsNil applies the IsNil predicate on the "material_name" field.
+func MaterialNameIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldMaterialName))
+}
+
+// MaterialNameNotNil applies the NotNil predicate on the "material_name" field.
+func MaterialNameNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldMaterialName))
+}
+
+// MaterialNameEqualFold applies the EqualFold predicate on the "material_name" field.
+func MaterialNameEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldMaterialName, v))
+}
+
+// MaterialNameContainsFold applies the ContainsFold predicate on the "material_name" field.
+func MaterialNameContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldMaterialName, v))
+}
+
+// ManageModeEQ applies the EQ predicate on the "manage_mode" field.
+func ManageModeEQ(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldManageMode, v))
+}
+
+// ManageModeNEQ applies the NEQ predicate on the "manage_mode" field.
+func ManageModeNEQ(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldManageMode, v))
+}
+
+// ManageModeIn applies the In predicate on the "manage_mode" field.
+func ManageModeIn(vs ...int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldManageMode, vs...))
+}
+
+// ManageModeNotIn applies the NotIn predicate on the "manage_mode" field.
+func ManageModeNotIn(vs ...int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldManageMode, vs...))
+}
+
+// ManageModeGT applies the GT predicate on the "manage_mode" field.
+func ManageModeGT(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldManageMode, v))
+}
+
+// ManageModeGTE applies the GTE predicate on the "manage_mode" field.
+func ManageModeGTE(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldManageMode, v))
+}
+
+// ManageModeLT applies the LT predicate on the "manage_mode" field.
+func ManageModeLT(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldManageMode, v))
+}
+
+// ManageModeLTE applies the LTE predicate on the "manage_mode" field.
+func ManageModeLTE(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldManageMode, v))
+}
+
+// BatchNoEQ applies the EQ predicate on the "batch_no" field.
+func BatchNoEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// BatchNoNEQ applies the NEQ predicate on the "batch_no" field.
+func BatchNoNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldBatchNo, v))
+}
+
+// BatchNoIn applies the In predicate on the "batch_no" field.
+func BatchNoIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldBatchNo, vs...))
+}
+
+// BatchNoNotIn applies the NotIn predicate on the "batch_no" field.
+func BatchNoNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldBatchNo, vs...))
+}
+
+// BatchNoGT applies the GT predicate on the "batch_no" field.
+func BatchNoGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldBatchNo, v))
+}
+
+// BatchNoGTE applies the GTE predicate on the "batch_no" field.
+func BatchNoGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldBatchNo, v))
+}
+
+// BatchNoLT applies the LT predicate on the "batch_no" field.
+func BatchNoLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldBatchNo, v))
+}
+
+// BatchNoLTE applies the LTE predicate on the "batch_no" field.
+func BatchNoLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldBatchNo, v))
+}
+
+// BatchNoContains applies the Contains predicate on the "batch_no" field.
+func BatchNoContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldBatchNo, v))
+}
+
+// BatchNoHasPrefix applies the HasPrefix predicate on the "batch_no" field.
+func BatchNoHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldBatchNo, v))
+}
+
+// BatchNoHasSuffix applies the HasSuffix predicate on the "batch_no" field.
+func BatchNoHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldBatchNo, v))
+}
+
+// BatchNoIsNil applies the IsNil predicate on the "batch_no" field.
+func BatchNoIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldBatchNo))
+}
+
+// BatchNoNotNil applies the NotNil predicate on the "batch_no" field.
+func BatchNoNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldBatchNo))
+}
+
+// BatchNoEqualFold applies the EqualFold predicate on the "batch_no" field.
+func BatchNoEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldBatchNo, v))
+}
+
+// BatchNoContainsFold applies the ContainsFold predicate on the "batch_no" field.
+func BatchNoContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldBatchNo, v))
+}
+
+// ZoneCodeEQ applies the EQ predicate on the "zone_code" field.
+func ZoneCodeEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeNEQ applies the NEQ predicate on the "zone_code" field.
+func ZoneCodeNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeIn applies the In predicate on the "zone_code" field.
+func ZoneCodeIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeNotIn applies the NotIn predicate on the "zone_code" field.
+func ZoneCodeNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeGT applies the GT predicate on the "zone_code" field.
+func ZoneCodeGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldZoneCode, v))
+}
+
+// ZoneCodeGTE applies the GTE predicate on the "zone_code" field.
+func ZoneCodeGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldZoneCode, v))
+}
+
+// ZoneCodeLT applies the LT predicate on the "zone_code" field.
+func ZoneCodeLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldZoneCode, v))
+}
+
+// ZoneCodeLTE applies the LTE predicate on the "zone_code" field.
+func ZoneCodeLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldZoneCode, v))
+}
+
+// ZoneCodeContains applies the Contains predicate on the "zone_code" field.
+func ZoneCodeContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldZoneCode, v))
+}
+
+// ZoneCodeHasPrefix applies the HasPrefix predicate on the "zone_code" field.
+func ZoneCodeHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldZoneCode, v))
+}
+
+// ZoneCodeHasSuffix applies the HasSuffix predicate on the "zone_code" field.
+func ZoneCodeHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldZoneCode, v))
+}
+
+// ZoneCodeIsNil applies the IsNil predicate on the "zone_code" field.
+func ZoneCodeIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldZoneCode))
+}
+
+// ZoneCodeNotNil applies the NotNil predicate on the "zone_code" field.
+func ZoneCodeNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldZoneCode))
+}
+
+// ZoneCodeEqualFold applies the EqualFold predicate on the "zone_code" field.
+func ZoneCodeEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldZoneCode, v))
+}
+
+// ZoneCodeContainsFold applies the ContainsFold predicate on the "zone_code" field.
+func ZoneCodeContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldZoneCode, v))
+}
+
+// ShelfNoEQ applies the EQ predicate on the "shelf_no" field.
+func ShelfNoEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// ShelfNoNEQ applies the NEQ predicate on the "shelf_no" field.
+func ShelfNoNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldShelfNo, v))
+}
+
+// ShelfNoIn applies the In predicate on the "shelf_no" field.
+func ShelfNoIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoNotIn applies the NotIn predicate on the "shelf_no" field.
+func ShelfNoNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoGT applies the GT predicate on the "shelf_no" field.
+func ShelfNoGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldShelfNo, v))
+}
+
+// ShelfNoGTE applies the GTE predicate on the "shelf_no" field.
+func ShelfNoGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldShelfNo, v))
+}
+
+// ShelfNoLT applies the LT predicate on the "shelf_no" field.
+func ShelfNoLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldShelfNo, v))
+}
+
+// ShelfNoLTE applies the LTE predicate on the "shelf_no" field.
+func ShelfNoLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldShelfNo, v))
+}
+
+// ShelfNoContains applies the Contains predicate on the "shelf_no" field.
+func ShelfNoContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldShelfNo, v))
+}
+
+// ShelfNoHasPrefix applies the HasPrefix predicate on the "shelf_no" field.
+func ShelfNoHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldShelfNo, v))
+}
+
+// ShelfNoHasSuffix applies the HasSuffix predicate on the "shelf_no" field.
+func ShelfNoHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldShelfNo, v))
+}
+
+// ShelfNoIsNil applies the IsNil predicate on the "shelf_no" field.
+func ShelfNoIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldShelfNo))
+}
+
+// ShelfNoNotNil applies the NotNil predicate on the "shelf_no" field.
+func ShelfNoNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldShelfNo))
+}
+
+// ShelfNoEqualFold applies the EqualFold predicate on the "shelf_no" field.
+func ShelfNoEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldShelfNo, v))
+}
+
+// ShelfNoContainsFold applies the ContainsFold predicate on the "shelf_no" field.
+func ShelfNoContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldShelfNo, v))
+}
+
+// LayerNoEQ applies the EQ predicate on the "layer_no" field.
+func LayerNoEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// LayerNoNEQ applies the NEQ predicate on the "layer_no" field.
+func LayerNoNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldLayerNo, v))
+}
+
+// LayerNoIn applies the In predicate on the "layer_no" field.
+func LayerNoIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldLayerNo, vs...))
+}
+
+// LayerNoNotIn applies the NotIn predicate on the "layer_no" field.
+func LayerNoNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldLayerNo, vs...))
+}
+
+// LayerNoGT applies the GT predicate on the "layer_no" field.
+func LayerNoGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldLayerNo, v))
+}
+
+// LayerNoGTE applies the GTE predicate on the "layer_no" field.
+func LayerNoGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldLayerNo, v))
+}
+
+// LayerNoLT applies the LT predicate on the "layer_no" field.
+func LayerNoLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldLayerNo, v))
+}
+
+// LayerNoLTE applies the LTE predicate on the "layer_no" field.
+func LayerNoLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldLayerNo, v))
+}
+
+// LayerNoContains applies the Contains predicate on the "layer_no" field.
+func LayerNoContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldLayerNo, v))
+}
+
+// LayerNoHasPrefix applies the HasPrefix predicate on the "layer_no" field.
+func LayerNoHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldLayerNo, v))
+}
+
+// LayerNoHasSuffix applies the HasSuffix predicate on the "layer_no" field.
+func LayerNoHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldLayerNo, v))
+}
+
+// LayerNoIsNil applies the IsNil predicate on the "layer_no" field.
+func LayerNoIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldLayerNo))
+}
+
+// LayerNoNotNil applies the NotNil predicate on the "layer_no" field.
+func LayerNoNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldLayerNo))
+}
+
+// LayerNoEqualFold applies the EqualFold predicate on the "layer_no" field.
+func LayerNoEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldLayerNo, v))
+}
+
+// LayerNoContainsFold applies the ContainsFold predicate on the "layer_no" field.
+func LayerNoContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldLayerNo, v))
+}
+
+// PositionNoEQ applies the EQ predicate on the "position_no" field.
+func PositionNoEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// PositionNoNEQ applies the NEQ predicate on the "position_no" field.
+func PositionNoNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldPositionNo, v))
+}
+
+// PositionNoIn applies the In predicate on the "position_no" field.
+func PositionNoIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldPositionNo, vs...))
+}
+
+// PositionNoNotIn applies the NotIn predicate on the "position_no" field.
+func PositionNoNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldPositionNo, vs...))
+}
+
+// PositionNoGT applies the GT predicate on the "position_no" field.
+func PositionNoGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldPositionNo, v))
+}
+
+// PositionNoGTE applies the GTE predicate on the "position_no" field.
+func PositionNoGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldPositionNo, v))
+}
+
+// PositionNoLT applies the LT predicate on the "position_no" field.
+func PositionNoLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldPositionNo, v))
+}
+
+// PositionNoLTE applies the LTE predicate on the "position_no" field.
+func PositionNoLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldPositionNo, v))
+}
+
+// PositionNoContains applies the Contains predicate on the "position_no" field.
+func PositionNoContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldPositionNo, v))
+}
+
+// PositionNoHasPrefix applies the HasPrefix predicate on the "position_no" field.
+func PositionNoHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldPositionNo, v))
+}
+
+// PositionNoHasSuffix applies the HasSuffix predicate on the "position_no" field.
+func PositionNoHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldPositionNo, v))
+}
+
+// PositionNoIsNil applies the IsNil predicate on the "position_no" field.
+func PositionNoIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldPositionNo))
+}
+
+// PositionNoNotNil applies the NotNil predicate on the "position_no" field.
+func PositionNoNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldPositionNo))
+}
+
+// PositionNoEqualFold applies the EqualFold predicate on the "position_no" field.
+func PositionNoEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldPositionNo, v))
+}
+
+// PositionNoContainsFold applies the ContainsFold predicate on the "position_no" field.
+func PositionNoContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldPositionNo, v))
+}
+
+// QuantityEQ applies the EQ predicate on the "quantity" field.
+func QuantityEQ(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldQuantity, v))
+}
+
+// QuantityNEQ applies the NEQ predicate on the "quantity" field.
+func QuantityNEQ(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldQuantity, v))
+}
+
+// QuantityIn applies the In predicate on the "quantity" field.
+func QuantityIn(vs ...int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldQuantity, vs...))
+}
+
+// QuantityNotIn applies the NotIn predicate on the "quantity" field.
+func QuantityNotIn(vs ...int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldQuantity, vs...))
+}
+
+// QuantityGT applies the GT predicate on the "quantity" field.
+func QuantityGT(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldQuantity, v))
+}
+
+// QuantityGTE applies the GTE predicate on the "quantity" field.
+func QuantityGTE(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldQuantity, v))
+}
+
+// QuantityLT applies the LT predicate on the "quantity" field.
+func QuantityLT(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldQuantity, v))
+}
+
+// QuantityLTE applies the LTE predicate on the "quantity" field.
+func QuantityLTE(v int) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldQuantity, v))
+}
+
+// OperatorEQ applies the EQ predicate on the "operator" field.
+func OperatorEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldOperator, v))
+}
+
+// OperatorNEQ applies the NEQ predicate on the "operator" field.
+func OperatorNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldOperator, v))
+}
+
+// OperatorIn applies the In predicate on the "operator" field.
+func OperatorIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldOperator, vs...))
+}
+
+// OperatorNotIn applies the NotIn predicate on the "operator" field.
+func OperatorNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldOperator, vs...))
+}
+
+// OperatorGT applies the GT predicate on the "operator" field.
+func OperatorGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldOperator, v))
+}
+
+// OperatorGTE applies the GTE predicate on the "operator" field.
+func OperatorGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldOperator, v))
+}
+
+// OperatorLT applies the LT predicate on the "operator" field.
+func OperatorLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldOperator, v))
+}
+
+// OperatorLTE applies the LTE predicate on the "operator" field.
+func OperatorLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldOperator, v))
+}
+
+// OperatorContains applies the Contains predicate on the "operator" field.
+func OperatorContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldOperator, v))
+}
+
+// OperatorHasPrefix applies the HasPrefix predicate on the "operator" field.
+func OperatorHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldOperator, v))
+}
+
+// OperatorHasSuffix applies the HasSuffix predicate on the "operator" field.
+func OperatorHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldOperator, v))
+}
+
+// OperatorIsNil applies the IsNil predicate on the "operator" field.
+func OperatorIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldOperator))
+}
+
+// OperatorNotNil applies the NotNil predicate on the "operator" field.
+func OperatorNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldOperator))
+}
+
+// OperatorEqualFold applies the EqualFold predicate on the "operator" field.
+func OperatorEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldOperator, v))
+}
+
+// OperatorContainsFold applies the ContainsFold predicate on the "operator" field.
+func OperatorContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldOperator, v))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// InspectionNoEQ applies the EQ predicate on the "inspection_no" field.
+func InspectionNoEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldInspectionNo, v))
+}
+
+// InspectionNoNEQ applies the NEQ predicate on the "inspection_no" field.
+func InspectionNoNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldInspectionNo, v))
+}
+
+// InspectionNoIn applies the In predicate on the "inspection_no" field.
+func InspectionNoIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldInspectionNo, vs...))
+}
+
+// InspectionNoNotIn applies the NotIn predicate on the "inspection_no" field.
+func InspectionNoNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldInspectionNo, vs...))
+}
+
+// InspectionNoGT applies the GT predicate on the "inspection_no" field.
+func InspectionNoGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldInspectionNo, v))
+}
+
+// InspectionNoGTE applies the GTE predicate on the "inspection_no" field.
+func InspectionNoGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldInspectionNo, v))
+}
+
+// InspectionNoLT applies the LT predicate on the "inspection_no" field.
+func InspectionNoLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldInspectionNo, v))
+}
+
+// InspectionNoLTE applies the LTE predicate on the "inspection_no" field.
+func InspectionNoLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldInspectionNo, v))
+}
+
+// InspectionNoContains applies the Contains predicate on the "inspection_no" field.
+func InspectionNoContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldInspectionNo, v))
+}
+
+// InspectionNoHasPrefix applies the HasPrefix predicate on the "inspection_no" field.
+func InspectionNoHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldInspectionNo, v))
+}
+
+// InspectionNoHasSuffix applies the HasSuffix predicate on the "inspection_no" field.
+func InspectionNoHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldInspectionNo, v))
+}
+
+// InspectionNoEqualFold applies the EqualFold predicate on the "inspection_no" field.
+func InspectionNoEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldInspectionNo, v))
+}
+
+// InspectionNoContainsFold applies the ContainsFold predicate on the "inspection_no" field.
+func InspectionNoContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldInspectionNo, v))
+}
+
+// OwnershipTypeEQ applies the EQ predicate on the "ownership_type" field.
+func OwnershipTypeEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldOwnershipType, v))
+}
+
+// OwnershipTypeNEQ applies the NEQ predicate on the "ownership_type" field.
+func OwnershipTypeNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldOwnershipType, v))
+}
+
+// OwnershipTypeIn applies the In predicate on the "ownership_type" field.
+func OwnershipTypeIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldOwnershipType, vs...))
+}
+
+// OwnershipTypeNotIn applies the NotIn predicate on the "ownership_type" field.
+func OwnershipTypeNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldOwnershipType, vs...))
+}
+
+// OwnershipTypeGT applies the GT predicate on the "ownership_type" field.
+func OwnershipTypeGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldOwnershipType, v))
+}
+
+// OwnershipTypeGTE applies the GTE predicate on the "ownership_type" field.
+func OwnershipTypeGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldOwnershipType, v))
+}
+
+// OwnershipTypeLT applies the LT predicate on the "ownership_type" field.
+func OwnershipTypeLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldOwnershipType, v))
+}
+
+// OwnershipTypeLTE applies the LTE predicate on the "ownership_type" field.
+func OwnershipTypeLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldOwnershipType, v))
+}
+
+// OwnershipTypeContains applies the Contains predicate on the "ownership_type" field.
+func OwnershipTypeContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldOwnershipType, v))
+}
+
+// OwnershipTypeHasPrefix applies the HasPrefix predicate on the "ownership_type" field.
+func OwnershipTypeHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldOwnershipType, v))
+}
+
+// OwnershipTypeHasSuffix applies the HasSuffix predicate on the "ownership_type" field.
+func OwnershipTypeHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldOwnershipType, v))
+}
+
+// OwnershipTypeEqualFold applies the EqualFold predicate on the "ownership_type" field.
+func OwnershipTypeEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldOwnershipType, v))
+}
+
+// OwnershipTypeContainsFold applies the ContainsFold predicate on the "ownership_type" field.
+func OwnershipTypeContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldOwnershipType, v))
+}
+
+// OwnershipNoEQ applies the EQ predicate on the "ownership_no" field.
+func OwnershipNoEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldOwnershipNo, v))
+}
+
+// OwnershipNoNEQ applies the NEQ predicate on the "ownership_no" field.
+func OwnershipNoNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldOwnershipNo, v))
+}
+
+// OwnershipNoIn applies the In predicate on the "ownership_no" field.
+func OwnershipNoIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldOwnershipNo, vs...))
+}
+
+// OwnershipNoNotIn applies the NotIn predicate on the "ownership_no" field.
+func OwnershipNoNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldOwnershipNo, vs...))
+}
+
+// OwnershipNoGT applies the GT predicate on the "ownership_no" field.
+func OwnershipNoGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldOwnershipNo, v))
+}
+
+// OwnershipNoGTE applies the GTE predicate on the "ownership_no" field.
+func OwnershipNoGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldOwnershipNo, v))
+}
+
+// OwnershipNoLT applies the LT predicate on the "ownership_no" field.
+func OwnershipNoLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldOwnershipNo, v))
+}
+
+// OwnershipNoLTE applies the LTE predicate on the "ownership_no" field.
+func OwnershipNoLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldOwnershipNo, v))
+}
+
+// OwnershipNoContains applies the Contains predicate on the "ownership_no" field.
+func OwnershipNoContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldOwnershipNo, v))
+}
+
+// OwnershipNoHasPrefix applies the HasPrefix predicate on the "ownership_no" field.
+func OwnershipNoHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldOwnershipNo, v))
+}
+
+// OwnershipNoHasSuffix applies the HasSuffix predicate on the "ownership_no" field.
+func OwnershipNoHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldOwnershipNo, v))
+}
+
+// OwnershipNoIsNil applies the IsNil predicate on the "ownership_no" field.
+func OwnershipNoIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldOwnershipNo))
+}
+
+// OwnershipNoNotNil applies the NotNil predicate on the "ownership_no" field.
+func OwnershipNoNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldOwnershipNo))
+}
+
+// OwnershipNoEqualFold applies the EqualFold predicate on the "ownership_no" field.
+func OwnershipNoEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldOwnershipNo, v))
+}
+
+// OwnershipNoContainsFold applies the ContainsFold predicate on the "ownership_no" field.
+func OwnershipNoContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldOwnershipNo, v))
+}
+
+// QualityStatusEQ applies the EQ predicate on the "quality_status" field.
+func QualityStatusEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldQualityStatus, v))
+}
+
+// QualityStatusNEQ applies the NEQ predicate on the "quality_status" field.
+func QualityStatusNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldQualityStatus, v))
+}
+
+// QualityStatusIn applies the In predicate on the "quality_status" field.
+func QualityStatusIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldQualityStatus, vs...))
+}
+
+// QualityStatusNotIn applies the NotIn predicate on the "quality_status" field.
+func QualityStatusNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldQualityStatus, vs...))
+}
+
+// QualityStatusGT applies the GT predicate on the "quality_status" field.
+func QualityStatusGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldQualityStatus, v))
+}
+
+// QualityStatusGTE applies the GTE predicate on the "quality_status" field.
+func QualityStatusGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldQualityStatus, v))
+}
+
+// QualityStatusLT applies the LT predicate on the "quality_status" field.
+func QualityStatusLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldQualityStatus, v))
+}
+
+// QualityStatusLTE applies the LTE predicate on the "quality_status" field.
+func QualityStatusLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldQualityStatus, v))
+}
+
+// QualityStatusContains applies the Contains predicate on the "quality_status" field.
+func QualityStatusContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldQualityStatus, v))
+}
+
+// QualityStatusHasPrefix applies the HasPrefix predicate on the "quality_status" field.
+func QualityStatusHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldQualityStatus, v))
+}
+
+// QualityStatusHasSuffix applies the HasSuffix predicate on the "quality_status" field.
+func QualityStatusHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldQualityStatus, v))
+}
+
+// QualityStatusIsNil applies the IsNil predicate on the "quality_status" field.
+func QualityStatusIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldQualityStatus))
+}
+
+// QualityStatusNotNil applies the NotNil predicate on the "quality_status" field.
+func QualityStatusNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldQualityStatus))
+}
+
+// QualityStatusEqualFold applies the EqualFold predicate on the "quality_status" field.
+func QualityStatusEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldQualityStatus, v))
+}
+
+// QualityStatusContainsFold applies the ContainsFold predicate on the "quality_status" field.
+func QualityStatusContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldQualityStatus, v))
+}
+
+// VoidedEQ applies the EQ predicate on the "voided" field.
+func VoidedEQ(v bool) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldVoided, v))
+}
+
+// VoidedNEQ applies the NEQ predicate on the "voided" field.
+func VoidedNEQ(v bool) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldVoided, v))
+}
+
+// VoidReasonEQ applies the EQ predicate on the "void_reason" field.
+func VoidReasonEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldVoidReason, v))
+}
+
+// VoidReasonNEQ applies the NEQ predicate on the "void_reason" field.
+func VoidReasonNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldVoidReason, v))
+}
+
+// VoidReasonIn applies the In predicate on the "void_reason" field.
+func VoidReasonIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldVoidReason, vs...))
+}
+
+// VoidReasonNotIn applies the NotIn predicate on the "void_reason" field.
+func VoidReasonNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldVoidReason, vs...))
+}
+
+// VoidReasonGT applies the GT predicate on the "void_reason" field.
+func VoidReasonGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldVoidReason, v))
+}
+
+// VoidReasonGTE applies the GTE predicate on the "void_reason" field.
+func VoidReasonGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldVoidReason, v))
+}
+
+// VoidReasonLT applies the LT predicate on the "void_reason" field.
+func VoidReasonLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldVoidReason, v))
+}
+
+// VoidReasonLTE applies the LTE predicate on the "void_reason" field.
+func VoidReasonLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldVoidReason, v))
+}
+
+// VoidReasonContains applies the Contains predicate on the "void_reason" field.
+func VoidReasonContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldVoidReason, v))
+}
+
+// VoidReasonHasPrefix applies the HasPrefix predicate on the "void_reason" field.
+func VoidReasonHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldVoidReason, v))
+}
+
+// VoidReasonHasSuffix applies the HasSuffix predicate on the "void_reason" field.
+func VoidReasonHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldVoidReason, v))
+}
+
+// VoidReasonIsNil applies the IsNil predicate on the "void_reason" field.
+func VoidReasonIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldVoidReason))
+}
+
+// VoidReasonNotNil applies the NotNil predicate on the "void_reason" field.
+func VoidReasonNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldVoidReason))
+}
+
+// VoidReasonEqualFold applies the EqualFold predicate on the "void_reason" field.
+func VoidReasonEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldVoidReason, v))
+}
+
+// VoidReasonContainsFold applies the ContainsFold predicate on the "void_reason" field.
+func VoidReasonContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldVoidReason, v))
+}
+
+// VoidedByEQ applies the EQ predicate on the "voided_by" field.
+func VoidedByEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldVoidedBy, v))
+}
+
+// VoidedByNEQ applies the NEQ predicate on the "voided_by" field.
+func VoidedByNEQ(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldVoidedBy, v))
+}
+
+// VoidedByIn applies the In predicate on the "voided_by" field.
+func VoidedByIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldVoidedBy, vs...))
+}
+
+// VoidedByNotIn applies the NotIn predicate on the "voided_by" field.
+func VoidedByNotIn(vs ...string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldVoidedBy, vs...))
+}
+
+// VoidedByGT applies the GT predicate on the "voided_by" field.
+func VoidedByGT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldVoidedBy, v))
+}
+
+// VoidedByGTE applies the GTE predicate on the "voided_by" field.
+func VoidedByGTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldVoidedBy, v))
+}
+
+// VoidedByLT applies the LT predicate on the "voided_by" field.
+func VoidedByLT(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldVoidedBy, v))
+}
+
+// VoidedByLTE applies the LTE predicate on the "voided_by" field.
+func VoidedByLTE(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldVoidedBy, v))
+}
+
+// VoidedByContains applies the Contains predicate on the "voided_by" field.
+func VoidedByContains(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContains(FieldVoidedBy, v))
+}
+
+// VoidedByHasPrefix applies the HasPrefix predicate on the "voided_by" field.
+func VoidedByHasPrefix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasPrefix(FieldVoidedBy, v))
+}
+
+// VoidedByHasSuffix applies the HasSuffix predicate on the "voided_by" field.
+func VoidedByHasSuffix(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldHasSuffix(FieldVoidedBy, v))
+}
+
+// VoidedByIsNil applies the IsNil predicate on the "voided_by" field.
+func VoidedByIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldVoidedBy))
+}
+
+// VoidedByNotNil applies the NotNil predicate on the "voided_by" field.
+func VoidedByNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldVoidedBy))
+}
+
+// VoidedByEqualFold applies the EqualFold predicate on the "voided_by" field.
+func VoidedByEqualFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEqualFold(FieldVoidedBy, v))
+}
+
+// VoidedByContainsFold applies the ContainsFold predicate on the "voided_by" field.
+func VoidedByContainsFold(v string) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldContainsFold(FieldVoidedBy, v))
+}
+
+// VoidedAtEQ applies the EQ predicate on the "voided_at" field.
+func VoidedAtEQ(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldVoidedAt, v))
+}
+
+// VoidedAtNEQ applies the NEQ predicate on the "voided_at" field.
+func VoidedAtNEQ(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldVoidedAt, v))
+}
+
+// VoidedAtIn applies the In predicate on the "voided_at" field.
+func VoidedAtIn(vs ...int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldVoidedAt, vs...))
+}
+
+// VoidedAtNotIn applies the NotIn predicate on the "voided_at" field.
+func VoidedAtNotIn(vs ...int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldVoidedAt, vs...))
+}
+
+// VoidedAtGT applies the GT predicate on the "voided_at" field.
+func VoidedAtGT(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldVoidedAt, v))
+}
+
+// VoidedAtGTE applies the GTE predicate on the "voided_at" field.
+func VoidedAtGTE(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldVoidedAt, v))
+}
+
+// VoidedAtLT applies the LT predicate on the "voided_at" field.
+func VoidedAtLT(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldVoidedAt, v))
+}
+
+// VoidedAtLTE applies the LTE predicate on the "voided_at" field.
+func VoidedAtLTE(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldVoidedAt, v))
+}
+
+// VoidedAtIsNil applies the IsNil predicate on the "voided_at" field.
+func VoidedAtIsNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIsNull(FieldVoidedAt))
+}
+
+// VoidedAtNotNil applies the NotNil predicate on the "voided_at" field.
+func VoidedAtNotNil() predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotNull(FieldVoidedAt))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.InboundOrder) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.InboundOrder) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.InboundOrder) predicate.InboundOrder {
+	return predicate.InboundOrder(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/inspectionrecord/inspectionrecord.go b/bj_power_wms/inspectionrecord/inspectionrecord.go
new file mode 100644
index 0000000..79f4295
--- /dev/null
+++ b/bj_power_wms/inspectionrecord/inspectionrecord.go
@@ -0,0 +1,250 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inspectionrecord
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the inspectionrecord type in the database.
+	Label = "inspection_record"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldTargetType holds the string denoting the target_type field in the database.
+	FieldTargetType = "target_type"
+	// FieldTargetID holds the string denoting the target_id field in the database.
+	FieldTargetID = "target_id"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldMaterialName holds the string denoting the material_name field in the database.
+	FieldMaterialName = "material_name"
+	// FieldOwnershipType holds the string denoting the ownership_type field in the database.
+	FieldOwnershipType = "ownership_type"
+	// FieldOwnershipNo holds the string denoting the ownership_no field in the database.
+	FieldOwnershipNo = "ownership_no"
+	// FieldRelatedStandard holds the string denoting the related_standard field in the database.
+	FieldRelatedStandard = "related_standard"
+	// FieldManufacturer holds the string denoting the manufacturer field in the database.
+	FieldManufacturer = "manufacturer"
+	// FieldInspectionType holds the string denoting the inspection_type field in the database.
+	FieldInspectionType = "inspection_type"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldResultValue holds the string denoting the result_value field in the database.
+	FieldResultValue = "result_value"
+	// FieldInspectQty holds the string denoting the inspect_qty field in the database.
+	FieldInspectQty = "inspect_qty"
+	// FieldPassQty holds the string denoting the pass_qty field in the database.
+	FieldPassQty = "pass_qty"
+	// FieldRejectQty holds the string denoting the reject_qty field in the database.
+	FieldRejectQty = "reject_qty"
+	// FieldCheckDesc holds the string denoting the check_desc field in the database.
+	FieldCheckDesc = "check_desc"
+	// FieldInspector holds the string denoting the inspector field in the database.
+	FieldInspector = "inspector"
+	// FieldInspectionNo holds the string denoting the inspection_no field in the database.
+	FieldInspectionNo = "inspection_no"
+	// FieldReportNo holds the string denoting the report_no field in the database.
+	FieldReportNo = "report_no"
+	// FieldDisposalType holds the string denoting the disposal_type field in the database.
+	FieldDisposalType = "disposal_type"
+	// FieldDisposalRemark holds the string denoting the disposal_remark field in the database.
+	FieldDisposalRemark = "disposal_remark"
+	// FieldReturnTrackingNo holds the string denoting the return_tracking_no field in the database.
+	FieldReturnTrackingNo = "return_tracking_no"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the inspectionrecord in the database.
+	Table = "inspection_records"
+)
+
+// Columns holds all SQL columns for inspectionrecord fields.
+var Columns = []string{
+	FieldID,
+	FieldTargetType,
+	FieldTargetID,
+	FieldMaterialCode,
+	FieldMaterialName,
+	FieldOwnershipType,
+	FieldOwnershipNo,
+	FieldRelatedStandard,
+	FieldManufacturer,
+	FieldInspectionType,
+	FieldStatus,
+	FieldResultValue,
+	FieldInspectQty,
+	FieldPassQty,
+	FieldRejectQty,
+	FieldCheckDesc,
+	FieldInspector,
+	FieldInspectionNo,
+	FieldReportNo,
+	FieldDisposalType,
+	FieldDisposalRemark,
+	FieldReturnTrackingNo,
+	FieldRemark,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultInspectionType holds the default value on creation for the "inspection_type" field.
+	DefaultInspectionType string
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultInspectQty holds the default value on creation for the "inspect_qty" field.
+	DefaultInspectQty int
+	// DefaultPassQty holds the default value on creation for the "pass_qty" field.
+	DefaultPassQty int
+	// DefaultRejectQty holds the default value on creation for the "reject_qty" field.
+	DefaultRejectQty int
+	// DefaultDisposalType holds the default value on creation for the "disposal_type" field.
+	DefaultDisposalType string
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the InspectionRecord queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByTargetType orders the results by the target_type field.
+func ByTargetType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetType, opts...).ToFunc()
+}
+
+// ByTargetID orders the results by the target_id field.
+func ByTargetID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetID, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByMaterialName orders the results by the material_name field.
+func ByMaterialName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialName, opts...).ToFunc()
+}
+
+// ByOwnershipType orders the results by the ownership_type field.
+func ByOwnershipType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOwnershipType, opts...).ToFunc()
+}
+
+// ByOwnershipNo orders the results by the ownership_no field.
+func ByOwnershipNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOwnershipNo, opts...).ToFunc()
+}
+
+// ByRelatedStandard orders the results by the related_standard field.
+func ByRelatedStandard(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRelatedStandard, opts...).ToFunc()
+}
+
+// ByManufacturer orders the results by the manufacturer field.
+func ByManufacturer(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldManufacturer, opts...).ToFunc()
+}
+
+// ByInspectionType orders the results by the inspection_type field.
+func ByInspectionType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInspectionType, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByResultValue orders the results by the result_value field.
+func ByResultValue(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldResultValue, opts...).ToFunc()
+}
+
+// ByInspectQty orders the results by the inspect_qty field.
+func ByInspectQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInspectQty, opts...).ToFunc()
+}
+
+// ByPassQty orders the results by the pass_qty field.
+func ByPassQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPassQty, opts...).ToFunc()
+}
+
+// ByRejectQty orders the results by the reject_qty field.
+func ByRejectQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRejectQty, opts...).ToFunc()
+}
+
+// ByCheckDesc orders the results by the check_desc field.
+func ByCheckDesc(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCheckDesc, opts...).ToFunc()
+}
+
+// ByInspector orders the results by the inspector field.
+func ByInspector(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInspector, opts...).ToFunc()
+}
+
+// ByInspectionNo orders the results by the inspection_no field.
+func ByInspectionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInspectionNo, opts...).ToFunc()
+}
+
+// ByReportNo orders the results by the report_no field.
+func ByReportNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReportNo, opts...).ToFunc()
+}
+
+// ByDisposalType orders the results by the disposal_type field.
+func ByDisposalType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDisposalType, opts...).ToFunc()
+}
+
+// ByDisposalRemark orders the results by the disposal_remark field.
+func ByDisposalRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDisposalRemark, opts...).ToFunc()
+}
+
+// ByReturnTrackingNo orders the results by the return_tracking_no field.
+func ByReturnTrackingNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReturnTrackingNo, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/inspectionrecord/where.go b/bj_power_wms/inspectionrecord/where.go
new file mode 100644
index 0000000..18581ca
--- /dev/null
+++ b/bj_power_wms/inspectionrecord/where.go
@@ -0,0 +1,1754 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inspectionrecord
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldID, id))
+}
+
+// TargetType applies equality check predicate on the "target_type" field. It's identical to TargetTypeEQ.
+func TargetType(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldTargetType, v))
+}
+
+// TargetID applies equality check predicate on the "target_id" field. It's identical to TargetIDEQ.
+func TargetID(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldTargetID, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialName applies equality check predicate on the "material_name" field. It's identical to MaterialNameEQ.
+func MaterialName(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// OwnershipType applies equality check predicate on the "ownership_type" field. It's identical to OwnershipTypeEQ.
+func OwnershipType(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldOwnershipType, v))
+}
+
+// OwnershipNo applies equality check predicate on the "ownership_no" field. It's identical to OwnershipNoEQ.
+func OwnershipNo(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldOwnershipNo, v))
+}
+
+// RelatedStandard applies equality check predicate on the "related_standard" field. It's identical to RelatedStandardEQ.
+func RelatedStandard(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldRelatedStandard, v))
+}
+
+// Manufacturer applies equality check predicate on the "manufacturer" field. It's identical to ManufacturerEQ.
+func Manufacturer(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldManufacturer, v))
+}
+
+// InspectionType applies equality check predicate on the "inspection_type" field. It's identical to InspectionTypeEQ.
+func InspectionType(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldInspectionType, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldStatus, v))
+}
+
+// ResultValue applies equality check predicate on the "result_value" field. It's identical to ResultValueEQ.
+func ResultValue(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldResultValue, v))
+}
+
+// InspectQty applies equality check predicate on the "inspect_qty" field. It's identical to InspectQtyEQ.
+func InspectQty(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldInspectQty, v))
+}
+
+// PassQty applies equality check predicate on the "pass_qty" field. It's identical to PassQtyEQ.
+func PassQty(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldPassQty, v))
+}
+
+// RejectQty applies equality check predicate on the "reject_qty" field. It's identical to RejectQtyEQ.
+func RejectQty(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldRejectQty, v))
+}
+
+// CheckDesc applies equality check predicate on the "check_desc" field. It's identical to CheckDescEQ.
+func CheckDesc(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldCheckDesc, v))
+}
+
+// Inspector applies equality check predicate on the "inspector" field. It's identical to InspectorEQ.
+func Inspector(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldInspector, v))
+}
+
+// InspectionNo applies equality check predicate on the "inspection_no" field. It's identical to InspectionNoEQ.
+func InspectionNo(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldInspectionNo, v))
+}
+
+// ReportNo applies equality check predicate on the "report_no" field. It's identical to ReportNoEQ.
+func ReportNo(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldReportNo, v))
+}
+
+// DisposalType applies equality check predicate on the "disposal_type" field. It's identical to DisposalTypeEQ.
+func DisposalType(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldDisposalType, v))
+}
+
+// DisposalRemark applies equality check predicate on the "disposal_remark" field. It's identical to DisposalRemarkEQ.
+func DisposalRemark(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldDisposalRemark, v))
+}
+
+// ReturnTrackingNo applies equality check predicate on the "return_tracking_no" field. It's identical to ReturnTrackingNoEQ.
+func ReturnTrackingNo(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldReturnTrackingNo, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldRemark, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// TargetTypeEQ applies the EQ predicate on the "target_type" field.
+func TargetTypeEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldTargetType, v))
+}
+
+// TargetTypeNEQ applies the NEQ predicate on the "target_type" field.
+func TargetTypeNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldTargetType, v))
+}
+
+// TargetTypeIn applies the In predicate on the "target_type" field.
+func TargetTypeIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldTargetType, vs...))
+}
+
+// TargetTypeNotIn applies the NotIn predicate on the "target_type" field.
+func TargetTypeNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldTargetType, vs...))
+}
+
+// TargetTypeGT applies the GT predicate on the "target_type" field.
+func TargetTypeGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldTargetType, v))
+}
+
+// TargetTypeGTE applies the GTE predicate on the "target_type" field.
+func TargetTypeGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldTargetType, v))
+}
+
+// TargetTypeLT applies the LT predicate on the "target_type" field.
+func TargetTypeLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldTargetType, v))
+}
+
+// TargetTypeLTE applies the LTE predicate on the "target_type" field.
+func TargetTypeLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldTargetType, v))
+}
+
+// TargetTypeContains applies the Contains predicate on the "target_type" field.
+func TargetTypeContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldTargetType, v))
+}
+
+// TargetTypeHasPrefix applies the HasPrefix predicate on the "target_type" field.
+func TargetTypeHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldTargetType, v))
+}
+
+// TargetTypeHasSuffix applies the HasSuffix predicate on the "target_type" field.
+func TargetTypeHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldTargetType, v))
+}
+
+// TargetTypeEqualFold applies the EqualFold predicate on the "target_type" field.
+func TargetTypeEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldTargetType, v))
+}
+
+// TargetTypeContainsFold applies the ContainsFold predicate on the "target_type" field.
+func TargetTypeContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldTargetType, v))
+}
+
+// TargetIDEQ applies the EQ predicate on the "target_id" field.
+func TargetIDEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldTargetID, v))
+}
+
+// TargetIDNEQ applies the NEQ predicate on the "target_id" field.
+func TargetIDNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldTargetID, v))
+}
+
+// TargetIDIn applies the In predicate on the "target_id" field.
+func TargetIDIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldTargetID, vs...))
+}
+
+// TargetIDNotIn applies the NotIn predicate on the "target_id" field.
+func TargetIDNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldTargetID, vs...))
+}
+
+// TargetIDGT applies the GT predicate on the "target_id" field.
+func TargetIDGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldTargetID, v))
+}
+
+// TargetIDGTE applies the GTE predicate on the "target_id" field.
+func TargetIDGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldTargetID, v))
+}
+
+// TargetIDLT applies the LT predicate on the "target_id" field.
+func TargetIDLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldTargetID, v))
+}
+
+// TargetIDLTE applies the LTE predicate on the "target_id" field.
+func TargetIDLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldTargetID, v))
+}
+
+// TargetIDContains applies the Contains predicate on the "target_id" field.
+func TargetIDContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldTargetID, v))
+}
+
+// TargetIDHasPrefix applies the HasPrefix predicate on the "target_id" field.
+func TargetIDHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldTargetID, v))
+}
+
+// TargetIDHasSuffix applies the HasSuffix predicate on the "target_id" field.
+func TargetIDHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldTargetID, v))
+}
+
+// TargetIDEqualFold applies the EqualFold predicate on the "target_id" field.
+func TargetIDEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldTargetID, v))
+}
+
+// TargetIDContainsFold applies the ContainsFold predicate on the "target_id" field.
+func TargetIDContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldTargetID, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// MaterialNameEQ applies the EQ predicate on the "material_name" field.
+func MaterialNameEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// MaterialNameNEQ applies the NEQ predicate on the "material_name" field.
+func MaterialNameNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldMaterialName, v))
+}
+
+// MaterialNameIn applies the In predicate on the "material_name" field.
+func MaterialNameIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameNotIn applies the NotIn predicate on the "material_name" field.
+func MaterialNameNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameGT applies the GT predicate on the "material_name" field.
+func MaterialNameGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldMaterialName, v))
+}
+
+// MaterialNameGTE applies the GTE predicate on the "material_name" field.
+func MaterialNameGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldMaterialName, v))
+}
+
+// MaterialNameLT applies the LT predicate on the "material_name" field.
+func MaterialNameLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldMaterialName, v))
+}
+
+// MaterialNameLTE applies the LTE predicate on the "material_name" field.
+func MaterialNameLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldMaterialName, v))
+}
+
+// MaterialNameContains applies the Contains predicate on the "material_name" field.
+func MaterialNameContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldMaterialName, v))
+}
+
+// MaterialNameHasPrefix applies the HasPrefix predicate on the "material_name" field.
+func MaterialNameHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldMaterialName, v))
+}
+
+// MaterialNameHasSuffix applies the HasSuffix predicate on the "material_name" field.
+func MaterialNameHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldMaterialName, v))
+}
+
+// MaterialNameIsNil applies the IsNil predicate on the "material_name" field.
+func MaterialNameIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldMaterialName))
+}
+
+// MaterialNameNotNil applies the NotNil predicate on the "material_name" field.
+func MaterialNameNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldMaterialName))
+}
+
+// MaterialNameEqualFold applies the EqualFold predicate on the "material_name" field.
+func MaterialNameEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldMaterialName, v))
+}
+
+// MaterialNameContainsFold applies the ContainsFold predicate on the "material_name" field.
+func MaterialNameContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldMaterialName, v))
+}
+
+// OwnershipTypeEQ applies the EQ predicate on the "ownership_type" field.
+func OwnershipTypeEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldOwnershipType, v))
+}
+
+// OwnershipTypeNEQ applies the NEQ predicate on the "ownership_type" field.
+func OwnershipTypeNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldOwnershipType, v))
+}
+
+// OwnershipTypeIn applies the In predicate on the "ownership_type" field.
+func OwnershipTypeIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldOwnershipType, vs...))
+}
+
+// OwnershipTypeNotIn applies the NotIn predicate on the "ownership_type" field.
+func OwnershipTypeNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldOwnershipType, vs...))
+}
+
+// OwnershipTypeGT applies the GT predicate on the "ownership_type" field.
+func OwnershipTypeGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldOwnershipType, v))
+}
+
+// OwnershipTypeGTE applies the GTE predicate on the "ownership_type" field.
+func OwnershipTypeGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldOwnershipType, v))
+}
+
+// OwnershipTypeLT applies the LT predicate on the "ownership_type" field.
+func OwnershipTypeLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldOwnershipType, v))
+}
+
+// OwnershipTypeLTE applies the LTE predicate on the "ownership_type" field.
+func OwnershipTypeLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldOwnershipType, v))
+}
+
+// OwnershipTypeContains applies the Contains predicate on the "ownership_type" field.
+func OwnershipTypeContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldOwnershipType, v))
+}
+
+// OwnershipTypeHasPrefix applies the HasPrefix predicate on the "ownership_type" field.
+func OwnershipTypeHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldOwnershipType, v))
+}
+
+// OwnershipTypeHasSuffix applies the HasSuffix predicate on the "ownership_type" field.
+func OwnershipTypeHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldOwnershipType, v))
+}
+
+// OwnershipTypeIsNil applies the IsNil predicate on the "ownership_type" field.
+func OwnershipTypeIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldOwnershipType))
+}
+
+// OwnershipTypeNotNil applies the NotNil predicate on the "ownership_type" field.
+func OwnershipTypeNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldOwnershipType))
+}
+
+// OwnershipTypeEqualFold applies the EqualFold predicate on the "ownership_type" field.
+func OwnershipTypeEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldOwnershipType, v))
+}
+
+// OwnershipTypeContainsFold applies the ContainsFold predicate on the "ownership_type" field.
+func OwnershipTypeContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldOwnershipType, v))
+}
+
+// OwnershipNoEQ applies the EQ predicate on the "ownership_no" field.
+func OwnershipNoEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldOwnershipNo, v))
+}
+
+// OwnershipNoNEQ applies the NEQ predicate on the "ownership_no" field.
+func OwnershipNoNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldOwnershipNo, v))
+}
+
+// OwnershipNoIn applies the In predicate on the "ownership_no" field.
+func OwnershipNoIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldOwnershipNo, vs...))
+}
+
+// OwnershipNoNotIn applies the NotIn predicate on the "ownership_no" field.
+func OwnershipNoNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldOwnershipNo, vs...))
+}
+
+// OwnershipNoGT applies the GT predicate on the "ownership_no" field.
+func OwnershipNoGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldOwnershipNo, v))
+}
+
+// OwnershipNoGTE applies the GTE predicate on the "ownership_no" field.
+func OwnershipNoGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldOwnershipNo, v))
+}
+
+// OwnershipNoLT applies the LT predicate on the "ownership_no" field.
+func OwnershipNoLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldOwnershipNo, v))
+}
+
+// OwnershipNoLTE applies the LTE predicate on the "ownership_no" field.
+func OwnershipNoLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldOwnershipNo, v))
+}
+
+// OwnershipNoContains applies the Contains predicate on the "ownership_no" field.
+func OwnershipNoContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldOwnershipNo, v))
+}
+
+// OwnershipNoHasPrefix applies the HasPrefix predicate on the "ownership_no" field.
+func OwnershipNoHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldOwnershipNo, v))
+}
+
+// OwnershipNoHasSuffix applies the HasSuffix predicate on the "ownership_no" field.
+func OwnershipNoHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldOwnershipNo, v))
+}
+
+// OwnershipNoIsNil applies the IsNil predicate on the "ownership_no" field.
+func OwnershipNoIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldOwnershipNo))
+}
+
+// OwnershipNoNotNil applies the NotNil predicate on the "ownership_no" field.
+func OwnershipNoNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldOwnershipNo))
+}
+
+// OwnershipNoEqualFold applies the EqualFold predicate on the "ownership_no" field.
+func OwnershipNoEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldOwnershipNo, v))
+}
+
+// OwnershipNoContainsFold applies the ContainsFold predicate on the "ownership_no" field.
+func OwnershipNoContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldOwnershipNo, v))
+}
+
+// RelatedStandardEQ applies the EQ predicate on the "related_standard" field.
+func RelatedStandardEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldRelatedStandard, v))
+}
+
+// RelatedStandardNEQ applies the NEQ predicate on the "related_standard" field.
+func RelatedStandardNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldRelatedStandard, v))
+}
+
+// RelatedStandardIn applies the In predicate on the "related_standard" field.
+func RelatedStandardIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldRelatedStandard, vs...))
+}
+
+// RelatedStandardNotIn applies the NotIn predicate on the "related_standard" field.
+func RelatedStandardNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldRelatedStandard, vs...))
+}
+
+// RelatedStandardGT applies the GT predicate on the "related_standard" field.
+func RelatedStandardGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldRelatedStandard, v))
+}
+
+// RelatedStandardGTE applies the GTE predicate on the "related_standard" field.
+func RelatedStandardGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldRelatedStandard, v))
+}
+
+// RelatedStandardLT applies the LT predicate on the "related_standard" field.
+func RelatedStandardLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldRelatedStandard, v))
+}
+
+// RelatedStandardLTE applies the LTE predicate on the "related_standard" field.
+func RelatedStandardLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldRelatedStandard, v))
+}
+
+// RelatedStandardContains applies the Contains predicate on the "related_standard" field.
+func RelatedStandardContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldRelatedStandard, v))
+}
+
+// RelatedStandardHasPrefix applies the HasPrefix predicate on the "related_standard" field.
+func RelatedStandardHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldRelatedStandard, v))
+}
+
+// RelatedStandardHasSuffix applies the HasSuffix predicate on the "related_standard" field.
+func RelatedStandardHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldRelatedStandard, v))
+}
+
+// RelatedStandardIsNil applies the IsNil predicate on the "related_standard" field.
+func RelatedStandardIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldRelatedStandard))
+}
+
+// RelatedStandardNotNil applies the NotNil predicate on the "related_standard" field.
+func RelatedStandardNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldRelatedStandard))
+}
+
+// RelatedStandardEqualFold applies the EqualFold predicate on the "related_standard" field.
+func RelatedStandardEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldRelatedStandard, v))
+}
+
+// RelatedStandardContainsFold applies the ContainsFold predicate on the "related_standard" field.
+func RelatedStandardContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldRelatedStandard, v))
+}
+
+// ManufacturerEQ applies the EQ predicate on the "manufacturer" field.
+func ManufacturerEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldManufacturer, v))
+}
+
+// ManufacturerNEQ applies the NEQ predicate on the "manufacturer" field.
+func ManufacturerNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldManufacturer, v))
+}
+
+// ManufacturerIn applies the In predicate on the "manufacturer" field.
+func ManufacturerIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldManufacturer, vs...))
+}
+
+// ManufacturerNotIn applies the NotIn predicate on the "manufacturer" field.
+func ManufacturerNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldManufacturer, vs...))
+}
+
+// ManufacturerGT applies the GT predicate on the "manufacturer" field.
+func ManufacturerGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldManufacturer, v))
+}
+
+// ManufacturerGTE applies the GTE predicate on the "manufacturer" field.
+func ManufacturerGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldManufacturer, v))
+}
+
+// ManufacturerLT applies the LT predicate on the "manufacturer" field.
+func ManufacturerLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldManufacturer, v))
+}
+
+// ManufacturerLTE applies the LTE predicate on the "manufacturer" field.
+func ManufacturerLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldManufacturer, v))
+}
+
+// ManufacturerContains applies the Contains predicate on the "manufacturer" field.
+func ManufacturerContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldManufacturer, v))
+}
+
+// ManufacturerHasPrefix applies the HasPrefix predicate on the "manufacturer" field.
+func ManufacturerHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldManufacturer, v))
+}
+
+// ManufacturerHasSuffix applies the HasSuffix predicate on the "manufacturer" field.
+func ManufacturerHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldManufacturer, v))
+}
+
+// ManufacturerIsNil applies the IsNil predicate on the "manufacturer" field.
+func ManufacturerIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldManufacturer))
+}
+
+// ManufacturerNotNil applies the NotNil predicate on the "manufacturer" field.
+func ManufacturerNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldManufacturer))
+}
+
+// ManufacturerEqualFold applies the EqualFold predicate on the "manufacturer" field.
+func ManufacturerEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldManufacturer, v))
+}
+
+// ManufacturerContainsFold applies the ContainsFold predicate on the "manufacturer" field.
+func ManufacturerContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldManufacturer, v))
+}
+
+// InspectionTypeEQ applies the EQ predicate on the "inspection_type" field.
+func InspectionTypeEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldInspectionType, v))
+}
+
+// InspectionTypeNEQ applies the NEQ predicate on the "inspection_type" field.
+func InspectionTypeNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldInspectionType, v))
+}
+
+// InspectionTypeIn applies the In predicate on the "inspection_type" field.
+func InspectionTypeIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldInspectionType, vs...))
+}
+
+// InspectionTypeNotIn applies the NotIn predicate on the "inspection_type" field.
+func InspectionTypeNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldInspectionType, vs...))
+}
+
+// InspectionTypeGT applies the GT predicate on the "inspection_type" field.
+func InspectionTypeGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldInspectionType, v))
+}
+
+// InspectionTypeGTE applies the GTE predicate on the "inspection_type" field.
+func InspectionTypeGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldInspectionType, v))
+}
+
+// InspectionTypeLT applies the LT predicate on the "inspection_type" field.
+func InspectionTypeLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldInspectionType, v))
+}
+
+// InspectionTypeLTE applies the LTE predicate on the "inspection_type" field.
+func InspectionTypeLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldInspectionType, v))
+}
+
+// InspectionTypeContains applies the Contains predicate on the "inspection_type" field.
+func InspectionTypeContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldInspectionType, v))
+}
+
+// InspectionTypeHasPrefix applies the HasPrefix predicate on the "inspection_type" field.
+func InspectionTypeHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldInspectionType, v))
+}
+
+// InspectionTypeHasSuffix applies the HasSuffix predicate on the "inspection_type" field.
+func InspectionTypeHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldInspectionType, v))
+}
+
+// InspectionTypeEqualFold applies the EqualFold predicate on the "inspection_type" field.
+func InspectionTypeEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldInspectionType, v))
+}
+
+// InspectionTypeContainsFold applies the ContainsFold predicate on the "inspection_type" field.
+func InspectionTypeContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldInspectionType, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// ResultValueEQ applies the EQ predicate on the "result_value" field.
+func ResultValueEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldResultValue, v))
+}
+
+// ResultValueNEQ applies the NEQ predicate on the "result_value" field.
+func ResultValueNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldResultValue, v))
+}
+
+// ResultValueIn applies the In predicate on the "result_value" field.
+func ResultValueIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldResultValue, vs...))
+}
+
+// ResultValueNotIn applies the NotIn predicate on the "result_value" field.
+func ResultValueNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldResultValue, vs...))
+}
+
+// ResultValueGT applies the GT predicate on the "result_value" field.
+func ResultValueGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldResultValue, v))
+}
+
+// ResultValueGTE applies the GTE predicate on the "result_value" field.
+func ResultValueGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldResultValue, v))
+}
+
+// ResultValueLT applies the LT predicate on the "result_value" field.
+func ResultValueLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldResultValue, v))
+}
+
+// ResultValueLTE applies the LTE predicate on the "result_value" field.
+func ResultValueLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldResultValue, v))
+}
+
+// ResultValueContains applies the Contains predicate on the "result_value" field.
+func ResultValueContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldResultValue, v))
+}
+
+// ResultValueHasPrefix applies the HasPrefix predicate on the "result_value" field.
+func ResultValueHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldResultValue, v))
+}
+
+// ResultValueHasSuffix applies the HasSuffix predicate on the "result_value" field.
+func ResultValueHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldResultValue, v))
+}
+
+// ResultValueIsNil applies the IsNil predicate on the "result_value" field.
+func ResultValueIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldResultValue))
+}
+
+// ResultValueNotNil applies the NotNil predicate on the "result_value" field.
+func ResultValueNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldResultValue))
+}
+
+// ResultValueEqualFold applies the EqualFold predicate on the "result_value" field.
+func ResultValueEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldResultValue, v))
+}
+
+// ResultValueContainsFold applies the ContainsFold predicate on the "result_value" field.
+func ResultValueContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldResultValue, v))
+}
+
+// InspectQtyEQ applies the EQ predicate on the "inspect_qty" field.
+func InspectQtyEQ(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldInspectQty, v))
+}
+
+// InspectQtyNEQ applies the NEQ predicate on the "inspect_qty" field.
+func InspectQtyNEQ(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldInspectQty, v))
+}
+
+// InspectQtyIn applies the In predicate on the "inspect_qty" field.
+func InspectQtyIn(vs ...int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldInspectQty, vs...))
+}
+
+// InspectQtyNotIn applies the NotIn predicate on the "inspect_qty" field.
+func InspectQtyNotIn(vs ...int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldInspectQty, vs...))
+}
+
+// InspectQtyGT applies the GT predicate on the "inspect_qty" field.
+func InspectQtyGT(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldInspectQty, v))
+}
+
+// InspectQtyGTE applies the GTE predicate on the "inspect_qty" field.
+func InspectQtyGTE(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldInspectQty, v))
+}
+
+// InspectQtyLT applies the LT predicate on the "inspect_qty" field.
+func InspectQtyLT(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldInspectQty, v))
+}
+
+// InspectQtyLTE applies the LTE predicate on the "inspect_qty" field.
+func InspectQtyLTE(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldInspectQty, v))
+}
+
+// PassQtyEQ applies the EQ predicate on the "pass_qty" field.
+func PassQtyEQ(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldPassQty, v))
+}
+
+// PassQtyNEQ applies the NEQ predicate on the "pass_qty" field.
+func PassQtyNEQ(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldPassQty, v))
+}
+
+// PassQtyIn applies the In predicate on the "pass_qty" field.
+func PassQtyIn(vs ...int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldPassQty, vs...))
+}
+
+// PassQtyNotIn applies the NotIn predicate on the "pass_qty" field.
+func PassQtyNotIn(vs ...int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldPassQty, vs...))
+}
+
+// PassQtyGT applies the GT predicate on the "pass_qty" field.
+func PassQtyGT(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldPassQty, v))
+}
+
+// PassQtyGTE applies the GTE predicate on the "pass_qty" field.
+func PassQtyGTE(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldPassQty, v))
+}
+
+// PassQtyLT applies the LT predicate on the "pass_qty" field.
+func PassQtyLT(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldPassQty, v))
+}
+
+// PassQtyLTE applies the LTE predicate on the "pass_qty" field.
+func PassQtyLTE(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldPassQty, v))
+}
+
+// RejectQtyEQ applies the EQ predicate on the "reject_qty" field.
+func RejectQtyEQ(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldRejectQty, v))
+}
+
+// RejectQtyNEQ applies the NEQ predicate on the "reject_qty" field.
+func RejectQtyNEQ(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldRejectQty, v))
+}
+
+// RejectQtyIn applies the In predicate on the "reject_qty" field.
+func RejectQtyIn(vs ...int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldRejectQty, vs...))
+}
+
+// RejectQtyNotIn applies the NotIn predicate on the "reject_qty" field.
+func RejectQtyNotIn(vs ...int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldRejectQty, vs...))
+}
+
+// RejectQtyGT applies the GT predicate on the "reject_qty" field.
+func RejectQtyGT(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldRejectQty, v))
+}
+
+// RejectQtyGTE applies the GTE predicate on the "reject_qty" field.
+func RejectQtyGTE(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldRejectQty, v))
+}
+
+// RejectQtyLT applies the LT predicate on the "reject_qty" field.
+func RejectQtyLT(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldRejectQty, v))
+}
+
+// RejectQtyLTE applies the LTE predicate on the "reject_qty" field.
+func RejectQtyLTE(v int) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldRejectQty, v))
+}
+
+// CheckDescEQ applies the EQ predicate on the "check_desc" field.
+func CheckDescEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldCheckDesc, v))
+}
+
+// CheckDescNEQ applies the NEQ predicate on the "check_desc" field.
+func CheckDescNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldCheckDesc, v))
+}
+
+// CheckDescIn applies the In predicate on the "check_desc" field.
+func CheckDescIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldCheckDesc, vs...))
+}
+
+// CheckDescNotIn applies the NotIn predicate on the "check_desc" field.
+func CheckDescNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldCheckDesc, vs...))
+}
+
+// CheckDescGT applies the GT predicate on the "check_desc" field.
+func CheckDescGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldCheckDesc, v))
+}
+
+// CheckDescGTE applies the GTE predicate on the "check_desc" field.
+func CheckDescGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldCheckDesc, v))
+}
+
+// CheckDescLT applies the LT predicate on the "check_desc" field.
+func CheckDescLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldCheckDesc, v))
+}
+
+// CheckDescLTE applies the LTE predicate on the "check_desc" field.
+func CheckDescLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldCheckDesc, v))
+}
+
+// CheckDescContains applies the Contains predicate on the "check_desc" field.
+func CheckDescContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldCheckDesc, v))
+}
+
+// CheckDescHasPrefix applies the HasPrefix predicate on the "check_desc" field.
+func CheckDescHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldCheckDesc, v))
+}
+
+// CheckDescHasSuffix applies the HasSuffix predicate on the "check_desc" field.
+func CheckDescHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldCheckDesc, v))
+}
+
+// CheckDescIsNil applies the IsNil predicate on the "check_desc" field.
+func CheckDescIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldCheckDesc))
+}
+
+// CheckDescNotNil applies the NotNil predicate on the "check_desc" field.
+func CheckDescNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldCheckDesc))
+}
+
+// CheckDescEqualFold applies the EqualFold predicate on the "check_desc" field.
+func CheckDescEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldCheckDesc, v))
+}
+
+// CheckDescContainsFold applies the ContainsFold predicate on the "check_desc" field.
+func CheckDescContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldCheckDesc, v))
+}
+
+// InspectorEQ applies the EQ predicate on the "inspector" field.
+func InspectorEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldInspector, v))
+}
+
+// InspectorNEQ applies the NEQ predicate on the "inspector" field.
+func InspectorNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldInspector, v))
+}
+
+// InspectorIn applies the In predicate on the "inspector" field.
+func InspectorIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldInspector, vs...))
+}
+
+// InspectorNotIn applies the NotIn predicate on the "inspector" field.
+func InspectorNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldInspector, vs...))
+}
+
+// InspectorGT applies the GT predicate on the "inspector" field.
+func InspectorGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldInspector, v))
+}
+
+// InspectorGTE applies the GTE predicate on the "inspector" field.
+func InspectorGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldInspector, v))
+}
+
+// InspectorLT applies the LT predicate on the "inspector" field.
+func InspectorLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldInspector, v))
+}
+
+// InspectorLTE applies the LTE predicate on the "inspector" field.
+func InspectorLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldInspector, v))
+}
+
+// InspectorContains applies the Contains predicate on the "inspector" field.
+func InspectorContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldInspector, v))
+}
+
+// InspectorHasPrefix applies the HasPrefix predicate on the "inspector" field.
+func InspectorHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldInspector, v))
+}
+
+// InspectorHasSuffix applies the HasSuffix predicate on the "inspector" field.
+func InspectorHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldInspector, v))
+}
+
+// InspectorIsNil applies the IsNil predicate on the "inspector" field.
+func InspectorIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldInspector))
+}
+
+// InspectorNotNil applies the NotNil predicate on the "inspector" field.
+func InspectorNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldInspector))
+}
+
+// InspectorEqualFold applies the EqualFold predicate on the "inspector" field.
+func InspectorEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldInspector, v))
+}
+
+// InspectorContainsFold applies the ContainsFold predicate on the "inspector" field.
+func InspectorContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldInspector, v))
+}
+
+// InspectionNoEQ applies the EQ predicate on the "inspection_no" field.
+func InspectionNoEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldInspectionNo, v))
+}
+
+// InspectionNoNEQ applies the NEQ predicate on the "inspection_no" field.
+func InspectionNoNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldInspectionNo, v))
+}
+
+// InspectionNoIn applies the In predicate on the "inspection_no" field.
+func InspectionNoIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldInspectionNo, vs...))
+}
+
+// InspectionNoNotIn applies the NotIn predicate on the "inspection_no" field.
+func InspectionNoNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldInspectionNo, vs...))
+}
+
+// InspectionNoGT applies the GT predicate on the "inspection_no" field.
+func InspectionNoGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldInspectionNo, v))
+}
+
+// InspectionNoGTE applies the GTE predicate on the "inspection_no" field.
+func InspectionNoGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldInspectionNo, v))
+}
+
+// InspectionNoLT applies the LT predicate on the "inspection_no" field.
+func InspectionNoLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldInspectionNo, v))
+}
+
+// InspectionNoLTE applies the LTE predicate on the "inspection_no" field.
+func InspectionNoLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldInspectionNo, v))
+}
+
+// InspectionNoContains applies the Contains predicate on the "inspection_no" field.
+func InspectionNoContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldInspectionNo, v))
+}
+
+// InspectionNoHasPrefix applies the HasPrefix predicate on the "inspection_no" field.
+func InspectionNoHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldInspectionNo, v))
+}
+
+// InspectionNoHasSuffix applies the HasSuffix predicate on the "inspection_no" field.
+func InspectionNoHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldInspectionNo, v))
+}
+
+// InspectionNoIsNil applies the IsNil predicate on the "inspection_no" field.
+func InspectionNoIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldInspectionNo))
+}
+
+// InspectionNoNotNil applies the NotNil predicate on the "inspection_no" field.
+func InspectionNoNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldInspectionNo))
+}
+
+// InspectionNoEqualFold applies the EqualFold predicate on the "inspection_no" field.
+func InspectionNoEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldInspectionNo, v))
+}
+
+// InspectionNoContainsFold applies the ContainsFold predicate on the "inspection_no" field.
+func InspectionNoContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldInspectionNo, v))
+}
+
+// ReportNoEQ applies the EQ predicate on the "report_no" field.
+func ReportNoEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldReportNo, v))
+}
+
+// ReportNoNEQ applies the NEQ predicate on the "report_no" field.
+func ReportNoNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldReportNo, v))
+}
+
+// ReportNoIn applies the In predicate on the "report_no" field.
+func ReportNoIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldReportNo, vs...))
+}
+
+// ReportNoNotIn applies the NotIn predicate on the "report_no" field.
+func ReportNoNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldReportNo, vs...))
+}
+
+// ReportNoGT applies the GT predicate on the "report_no" field.
+func ReportNoGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldReportNo, v))
+}
+
+// ReportNoGTE applies the GTE predicate on the "report_no" field.
+func ReportNoGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldReportNo, v))
+}
+
+// ReportNoLT applies the LT predicate on the "report_no" field.
+func ReportNoLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldReportNo, v))
+}
+
+// ReportNoLTE applies the LTE predicate on the "report_no" field.
+func ReportNoLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldReportNo, v))
+}
+
+// ReportNoContains applies the Contains predicate on the "report_no" field.
+func ReportNoContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldReportNo, v))
+}
+
+// ReportNoHasPrefix applies the HasPrefix predicate on the "report_no" field.
+func ReportNoHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldReportNo, v))
+}
+
+// ReportNoHasSuffix applies the HasSuffix predicate on the "report_no" field.
+func ReportNoHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldReportNo, v))
+}
+
+// ReportNoIsNil applies the IsNil predicate on the "report_no" field.
+func ReportNoIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldReportNo))
+}
+
+// ReportNoNotNil applies the NotNil predicate on the "report_no" field.
+func ReportNoNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldReportNo))
+}
+
+// ReportNoEqualFold applies the EqualFold predicate on the "report_no" field.
+func ReportNoEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldReportNo, v))
+}
+
+// ReportNoContainsFold applies the ContainsFold predicate on the "report_no" field.
+func ReportNoContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldReportNo, v))
+}
+
+// DisposalTypeEQ applies the EQ predicate on the "disposal_type" field.
+func DisposalTypeEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldDisposalType, v))
+}
+
+// DisposalTypeNEQ applies the NEQ predicate on the "disposal_type" field.
+func DisposalTypeNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldDisposalType, v))
+}
+
+// DisposalTypeIn applies the In predicate on the "disposal_type" field.
+func DisposalTypeIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldDisposalType, vs...))
+}
+
+// DisposalTypeNotIn applies the NotIn predicate on the "disposal_type" field.
+func DisposalTypeNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldDisposalType, vs...))
+}
+
+// DisposalTypeGT applies the GT predicate on the "disposal_type" field.
+func DisposalTypeGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldDisposalType, v))
+}
+
+// DisposalTypeGTE applies the GTE predicate on the "disposal_type" field.
+func DisposalTypeGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldDisposalType, v))
+}
+
+// DisposalTypeLT applies the LT predicate on the "disposal_type" field.
+func DisposalTypeLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldDisposalType, v))
+}
+
+// DisposalTypeLTE applies the LTE predicate on the "disposal_type" field.
+func DisposalTypeLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldDisposalType, v))
+}
+
+// DisposalTypeContains applies the Contains predicate on the "disposal_type" field.
+func DisposalTypeContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldDisposalType, v))
+}
+
+// DisposalTypeHasPrefix applies the HasPrefix predicate on the "disposal_type" field.
+func DisposalTypeHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldDisposalType, v))
+}
+
+// DisposalTypeHasSuffix applies the HasSuffix predicate on the "disposal_type" field.
+func DisposalTypeHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldDisposalType, v))
+}
+
+// DisposalTypeEqualFold applies the EqualFold predicate on the "disposal_type" field.
+func DisposalTypeEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldDisposalType, v))
+}
+
+// DisposalTypeContainsFold applies the ContainsFold predicate on the "disposal_type" field.
+func DisposalTypeContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldDisposalType, v))
+}
+
+// DisposalRemarkEQ applies the EQ predicate on the "disposal_remark" field.
+func DisposalRemarkEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkNEQ applies the NEQ predicate on the "disposal_remark" field.
+func DisposalRemarkNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkIn applies the In predicate on the "disposal_remark" field.
+func DisposalRemarkIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldDisposalRemark, vs...))
+}
+
+// DisposalRemarkNotIn applies the NotIn predicate on the "disposal_remark" field.
+func DisposalRemarkNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldDisposalRemark, vs...))
+}
+
+// DisposalRemarkGT applies the GT predicate on the "disposal_remark" field.
+func DisposalRemarkGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkGTE applies the GTE predicate on the "disposal_remark" field.
+func DisposalRemarkGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkLT applies the LT predicate on the "disposal_remark" field.
+func DisposalRemarkLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkLTE applies the LTE predicate on the "disposal_remark" field.
+func DisposalRemarkLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkContains applies the Contains predicate on the "disposal_remark" field.
+func DisposalRemarkContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkHasPrefix applies the HasPrefix predicate on the "disposal_remark" field.
+func DisposalRemarkHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkHasSuffix applies the HasSuffix predicate on the "disposal_remark" field.
+func DisposalRemarkHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkIsNil applies the IsNil predicate on the "disposal_remark" field.
+func DisposalRemarkIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldDisposalRemark))
+}
+
+// DisposalRemarkNotNil applies the NotNil predicate on the "disposal_remark" field.
+func DisposalRemarkNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldDisposalRemark))
+}
+
+// DisposalRemarkEqualFold applies the EqualFold predicate on the "disposal_remark" field.
+func DisposalRemarkEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldDisposalRemark, v))
+}
+
+// DisposalRemarkContainsFold applies the ContainsFold predicate on the "disposal_remark" field.
+func DisposalRemarkContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldDisposalRemark, v))
+}
+
+// ReturnTrackingNoEQ applies the EQ predicate on the "return_tracking_no" field.
+func ReturnTrackingNoEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoNEQ applies the NEQ predicate on the "return_tracking_no" field.
+func ReturnTrackingNoNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoIn applies the In predicate on the "return_tracking_no" field.
+func ReturnTrackingNoIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldReturnTrackingNo, vs...))
+}
+
+// ReturnTrackingNoNotIn applies the NotIn predicate on the "return_tracking_no" field.
+func ReturnTrackingNoNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldReturnTrackingNo, vs...))
+}
+
+// ReturnTrackingNoGT applies the GT predicate on the "return_tracking_no" field.
+func ReturnTrackingNoGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoGTE applies the GTE predicate on the "return_tracking_no" field.
+func ReturnTrackingNoGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoLT applies the LT predicate on the "return_tracking_no" field.
+func ReturnTrackingNoLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoLTE applies the LTE predicate on the "return_tracking_no" field.
+func ReturnTrackingNoLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoContains applies the Contains predicate on the "return_tracking_no" field.
+func ReturnTrackingNoContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoHasPrefix applies the HasPrefix predicate on the "return_tracking_no" field.
+func ReturnTrackingNoHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoHasSuffix applies the HasSuffix predicate on the "return_tracking_no" field.
+func ReturnTrackingNoHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoIsNil applies the IsNil predicate on the "return_tracking_no" field.
+func ReturnTrackingNoIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldReturnTrackingNo))
+}
+
+// ReturnTrackingNoNotNil applies the NotNil predicate on the "return_tracking_no" field.
+func ReturnTrackingNoNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldReturnTrackingNo))
+}
+
+// ReturnTrackingNoEqualFold applies the EqualFold predicate on the "return_tracking_no" field.
+func ReturnTrackingNoEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldReturnTrackingNo, v))
+}
+
+// ReturnTrackingNoContainsFold applies the ContainsFold predicate on the "return_tracking_no" field.
+func ReturnTrackingNoContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldReturnTrackingNo, v))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.InspectionRecord) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.InspectionRecord) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.InspectionRecord) predicate.InspectionRecord {
+	return predicate.InspectionRecord(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/internal/db/db.go b/bj_power_wms/internal/db/db.go
index 658a469..9267c4c 100644
--- a/bj_power_wms/internal/db/db.go
+++ b/bj_power_wms/internal/db/db.go
@@ -236,6 +236,33 @@ func applyColumnPatches(ctx context.Context) {
 		`ALTER TABLE inbound_orders ADD COLUMN IF NOT EXISTS void_reason text`,
 		`ALTER TABLE inbound_orders ADD COLUMN IF NOT EXISTS voided_by text`,
 		`ALTER TABLE inbound_orders ADD COLUMN IF NOT EXISTS voided_at bigint`,
+		// ===== 2026-09-21 单号格式升级：IB/OB + YYYYMMDD + NNN + 高频查询字段统一加索引 =====
+		// 单号唯一：防止手工/自动生成撞号，应用层 validateUniqueNo 只做业务友好校验，DB 端唯一约束才是硬保证
+		// 注：存量库若有重复 IB433efbcc 这种旧单号会导致建索引失败，先在控制台 SELECT inbound_no, COUNT(*) GROUP BY 清掉重复
+		`CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS ux_inbound_orders_inbound_no ON inbound_orders (inbound_no)`,
+		`CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS ux_outbound_orders_outbound_no ON outbound_orders (outbound_no)`,
+		// 出库单也挂检测单号——退货/报废等场景需要溯源检验单据
+		`ALTER TABLE outbound_orders ADD COLUMN IF NOT EXISTS inspection_no text DEFAULT ''`,
+		// 高频查询/关联字段（ORDER BY / WHERE / JOIN）
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inbound_orders_created_at ON inbound_orders (created_at DESC)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inbound_orders_material_code ON inbound_orders (material_code)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inbound_orders_inspection_no ON inbound_orders (inspection_no)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_outbound_orders_order_no ON outbound_orders (order_no)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_outbound_orders_material_code ON outbound_orders (material_code)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_outbound_orders_inspection_no ON outbound_orders (inspection_no)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inventories_inbound_no ON inventories (inbound_no)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inventories_outbound_no ON inventories (outbound_no)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inventories_material_code ON inventories (material_code)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inventories_quality_status ON inventories (quality_status)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inventories_manage_mode ON inventories (manage_mode)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_outbound_details_outbound_no ON outbound_details (outbound_no)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inbound_details_inbound_no ON inbound_details (inbound_no)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inspection_records_target_id ON inspection_records (target_id)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inspection_records_inspection_no ON inspection_records (inspection_no)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_inspection_records_status ON inspection_records (status)`,
+		`CREATE INDEX CONCURRENTLY IF NOT EXISTS idx_materials_code ON materials (code)`,
+		`CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS ux_order_material_ledger_order_material ON order_material_ledgers (order_no, material_code)`,
+		`CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS ux_agv_tasks_task_no ON agv_tasks (task_no)`,
 		// 附件：新存储方案（年/月/日/文件类型/uuid.ext）——补文件类型/UUID名/相对路径/逻辑删除/归档列
 		`ALTER TABLE attachments ADD COLUMN IF NOT EXISTS file_type text`,
 		`ALTER TABLE attachments ADD COLUMN IF NOT EXISTS file_ext text`,
diff --git a/bj_power_wms/internal/handler/excel.go b/bj_power_wms/internal/handler/excel.go
index 9a1e8b4..588a47b 100644
--- a/bj_power_wms/internal/handler/excel.go
+++ b/bj_power_wms/internal/handler/excel.go
@@ -14,7 +14,6 @@ import (
 	"bj_power_wms/ent/material"
 	"bj_power_wms/internal/svc"
 
-	"github.com/google/uuid"
 	"github.com/xuri/excelize/v2"
 )
 
@@ -313,14 +312,14 @@ func excelInboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 					continue
 				}
 				if snSeen[pr.sn] {
-					errs = append(errs, importErr{pr.row, pr.code, "SN 在文件中重复: "+pr.sn})
+					errs = append(errs, importErr{pr.row, pr.code, "SN 在文件中重复: " + pr.sn})
 					continue
 				}
 				snSeen[pr.sn] = true
 				exists, _ := ctx.EntClient.Inventory.Query().
 					Where(inventory.ManageModeEQ(2), inventory.SnCodeEQ(pr.sn)).Exist(ctx0())
 				if exists {
-					errs = append(errs, importErr{pr.row, pr.code, "SN 已存在: "+pr.sn})
+					errs = append(errs, importErr{pr.row, pr.code, "SN 已存在: " + pr.sn})
 					continue
 				}
 			} else {
@@ -352,6 +351,7 @@ func excelInboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 			fail(w, http.StatusInternalServerError, "开启事务失败: "+e.Error())
 			return
 		}
+		var generatedNos []string
 		committed := false
 		defer func() {
 			if !committed {
@@ -360,7 +360,8 @@ func excelInboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 		}()
 
 		for _, pr := range plans {
-			inboundNo := "IB" + uuid.NewString()[:12]
+			inboundNo, _ := nextDailyNo(ctx, "IB")
+			generatedNos = append(generatedNos, inboundNo)
 			m, _ := tx.Material.Query().Where(material.CodeEQ(pr.code)).Only(ctx0())
 			if mode == "sn" {
 				if _, e = tx.Inventory.Create().
@@ -386,11 +387,11 @@ func excelInboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 					return
 				}
 			} else {
-			batchNo := pr.batchNo
-			if batchNo == "" {
-				// 自动批次号（物料编码-日期-流水号）；同一导入内多行空批次自动取得递增流水，天然唯一
-				batchNo = genBatchNo(ctx, pr.code)
-			}
+				batchNo := pr.batchNo
+				if batchNo == "" {
+					// 自动批次号（物料编码-日期-流水号）；同一导入内多行空批次自动取得递增流水，天然唯一
+					batchNo = genBatchNo(ctx, pr.code)
+				}
 				existing, e2 := tx.Inventory.Query().
 					Where(inventory.ManageModeEQ(1), inventory.BatchNoEQ(batchNo)).Only(ctx0())
 				if e2 == nil {
@@ -447,7 +448,12 @@ func excelInboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 			return
 		}
 		committed = true
-		ok(w, map[string]any{"success": len(plans), "failed": 0, "errors": []importErr{}})
+		ok(w, map[string]any{
+			"success":    len(plans),
+			"failed":     0,
+			"errors":     []importErr{},
+			"inboundNos": generatedNos, // 每张入库单生成的单号（与导入行一一对应）
+		})
 	}
 }
 
diff --git a/bj_power_wms/internal/handler/inbound.go b/bj_power_wms/internal/handler/inbound.go
index e49c635..7bb35a8 100644
--- a/bj_power_wms/internal/handler/inbound.go
+++ b/bj_power_wms/internal/handler/inbound.go
@@ -13,15 +13,102 @@ import (
 	"bj_power_wms/ent/inspectionrecord"
 	"bj_power_wms/ent/inventory"
 	"bj_power_wms/ent/material"
+	"bj_power_wms/ent/outboundorder"
 	"bj_power_wms/internal/svc"
 
-	"github.com/google/uuid"
 	"github.com/zeromicro/go-zero/core/logx"
 )
 
 // 物料品类：4=其他（辅料/工装/试验设备），与 schema/material.go 的 item_type 保持一致
 const invItemOther = 4
 
+// nextDailyNo 生成日期+流水号，格式：IB/OB + YYYYMMDD + -NNN（如 IB20260921-001）。
+// 同一天内流水号递增，跨天重置为 001。并发冲突时自动重试最多 5 次。
+// 注意：历史旧单号（IB+UUID 片段）不受影响，仅新生成的用新格式。
+func nextDailyNo(ctx *svc.ServiceContext, prefix string) (string, error) {
+	const maxRetry = 5
+	var lastErr error
+	for attempt := 0; attempt < maxRetry; attempt++ {
+		no, err := genDailyNoOnce(ctx, prefix)
+		if err != nil {
+			lastErr = err
+			time.Sleep(20 * time.Millisecond * time.Duration(attempt+1))
+			continue
+		}
+		// 校验唯一性——如果刚好撞号，重试
+		if prefix == "IB" {
+			if _, e := ctx.EntClient.InboundOrder.Query().Where(inboundorder.InboundNoEQ(no)).Only(ctx0()); e == nil {
+				lastErr = fmt.Errorf("单号 %s 已存在，重试中", no)
+				time.Sleep(20 * time.Millisecond * time.Duration(attempt+1))
+				continue
+			}
+		} else if prefix == "OB" {
+			if _, e := ctx.EntClient.OutboundOrder.Query().Where(outboundorder.OutboundNoEQ(no)).Only(ctx0()); e == nil {
+				lastErr = fmt.Errorf("单号 %s 已存在，重试中", no)
+				time.Sleep(20 * time.Millisecond * time.Duration(attempt+1))
+				continue
+			}
+		}
+		return no, nil
+	}
+	if lastErr != nil {
+		return "", fmt.Errorf("生成单号失败（重试 %d 次仍冲突）: %w", maxRetry, lastErr)
+	}
+	return "", fmt.Errorf("生成单号失败（未知错误）")
+}
+
+func genDailyNoOnce(ctx *svc.ServiceContext, prefix string) (string, error) {
+	now := time.Now()
+	datePart := now.Format("20060102")
+	prefixDate := prefix + datePart + "-"
+
+	var maxSeq int
+	var rows []string
+	var err error
+	if prefix == "IB" {
+		rows, err = ctx.EntClient.InboundOrder.Query().
+			Where(inboundorder.InboundNoHasPrefix(prefixDate)).
+			Select(inboundorder.FieldInboundNo).
+			Strings(ctx0())
+	} else if prefix == "OB" {
+		rows, err = ctx.EntClient.OutboundOrder.Query().
+			Where(outboundorder.OutboundNoHasPrefix(prefixDate)).
+			Select(outboundorder.FieldOutboundNo).
+			Strings(ctx0())
+	} else {
+		return "", fmt.Errorf("未知前缀: %s", prefix)
+	}
+	if err != nil {
+		return "", err
+	}
+	for _, n := range rows {
+		suffix := strings.TrimPrefix(n, prefixDate)
+		if s, e := strconv.Atoi(suffix); e == nil && s > maxSeq {
+			maxSeq = s
+		}
+	}
+	seq := maxSeq + 1
+	return fmt.Sprintf("%s%03d", prefixDate, seq), nil
+}
+
+// validateUniqueNo 校验单据号唯一（InboundNo 或 OutboundNo 不能重复）。
+func validateUniqueNo(ctx *svc.ServiceContext, kind, no string) error {
+	if no == "" {
+		return nil // 空值表示走自动生成
+	}
+	switch kind {
+	case "IB":
+		if _, e := ctx.EntClient.InboundOrder.Query().Where(inboundorder.InboundNoEQ(no)).Only(ctx0()); e == nil {
+			return fmt.Errorf("入库单号 %s 已存在", no)
+		}
+	case "OB":
+		if _, e := ctx.EntClient.OutboundOrder.Query().Where(outboundorder.OutboundNoEQ(no)).Only(ctx0()); e == nil {
+			return fmt.Errorf("出库单号 %s 已存在", no)
+		}
+	}
+	return nil
+}
+
 // validateInboundQuality 入库质量门禁：该物料/批次/SN 若已被判定"不合格"，拒绝入库。
 // 依据客户诉求《问题记录》L135：「不合格不入库、不上产线，仅合格品入库存数量」。
 func validateInboundQuality(ctx *svc.ServiceContext, materialCode, batchNo string, snList []string) error {
@@ -58,6 +145,7 @@ func validateInboundQuality(ctx *svc.ServiceContext, materialCode, batchNo strin
 func createInboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 	return func(w http.ResponseWriter, r *http.Request) {
 		var req struct {
+			InboundNo      string   `json:"inboundNo"`   // 可选：留空自动生成；填了必须唯一（如 IB20260921-001）
 			InboundType    string   `json:"inboundType"` // purchase/semi/finished/return/other
 			MaterialCode   string   `json:"materialCode"`
 			BatchNo        string   `json:"batchNo"`
@@ -117,7 +205,20 @@ func createInboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 			return
 		}
 
-		inboundNo := "IB" + uuid.NewString()[:12]
+		inboundNo := strings.TrimSpace(req.InboundNo)
+		if inboundNo != "" {
+			if err := validateUniqueNo(ctx, "IB", inboundNo); err != nil {
+				fail(w, http.StatusBadRequest, err.Error())
+				return
+			}
+		} else {
+			no, err := nextDailyNo(ctx, "IB")
+			if err != nil {
+				fail(w, http.StatusInternalServerError, "生成入库单号失败: "+err.Error())
+				return
+			}
+			inboundNo = no
+		}
 
 		// 质量状态自动带出（客户诉求 问题记录 L129：入库记录增加 合格/不合格 列）
 		// 按检测单号查最近一次检验结论：合格→合格；不合格且部分入库→部分；不合格→不合格；无记录→空(未关联)
@@ -348,6 +449,9 @@ func applyInboundFilters(q *ent.InboundOrderQuery, r *http.Request) *ent.Inbound
 		// 2026-09-08 用户明确：禁止"关键字"多字段混搜，各字段独立筛选
 		q = q.Where(inboundorder.MaterialNameContainsFold(v))
 	}
+	if v := r.URL.Query().Get("inspectionNo"); v != "" {
+		q = q.Where(inboundorder.InspectionNoContainsFold(v))
+	}
 	// 单据状态：有效 / 已作废（作废单保留可查，但不参与库存）
 	if v := r.URL.Query().Get("voided"); v == "true" {
 		q = q.Where(inboundorder.VoidedEQ(true))
diff --git a/bj_power_wms/internal/handler/inspection.go b/bj_power_wms/internal/handler/inspection.go
index 02c7ad8..6e856d9 100644
--- a/bj_power_wms/internal/handler/inspection.go
+++ b/bj_power_wms/internal/handler/inspection.go
@@ -3,6 +3,7 @@ package handler
 import (
 	"fmt"
 	"net/http"
+	"strconv"
 	"time"
 
 	"bj_power_wms/ent"
@@ -680,28 +681,18 @@ func inboundNosByType(ctx *svc.ServiceContext, inboundType string) ([]string, er
 	return nos, nil
 }
 
-// pendingInspectionItem 待检清单展开明细行
-type pendingInspectionItem struct {
-	ID         int    `json:"id"`         // inventory.id（真实主键，禁止伪 id）
-	TargetId   string `json:"targetId"`   // 批次号或 SN
-	ManageMode int    `json:"manageMode"` // 1结构件/2电气件
-	ItemType   int    `json:"itemType"`   // 品类 1原材料/2半成品/3成品/4其他（§E：带入录入页判定其他类）
-	Quantity   int    `json:"quantity"`
-	ZoneCode   string `json:"zoneCode"`
-}
-
 // pendingInspectionRow 待检清单主行（按 入库单 + 物料 分组，§E2）
+// 详情明细改为按需分页加载（右侧抽屉），主行只带总数不塞 details 数组，避免 3000 SN 一次进内存
 type pendingInspectionRow struct {
-	InboundNo      string                  `json:"inboundNo"`
-	InboundType    string                  `json:"inboundType"`
-	OwnershipType  string                  `json:"ownershipType"`
-	OwnershipNo    string                  `json:"ownershipNo"`
-	MaterialCode   string                  `json:"materialCode"`
-	MaterialName   string                  `json:"materialName"`
-	UnInspectedQty int                     `json:"unInspectedQty"` // 未检数量（结构件=数量求和；电气件=SN 行数）
-	BatchSnCount   int                     `json:"batchSnCount"`   // 未检批次数/SN 数
-	InboundTime    int64                   `json:"inboundTime"`
-	Details        []pendingInspectionItem `json:"details"`
+	InboundNo      string `json:"inboundNo"`
+	InboundType    string `json:"inboundType"`
+	OwnershipType  string `json:"ownershipType"`
+	OwnershipNo    string `json:"ownershipNo"`
+	MaterialCode   string `json:"materialCode"`
+	MaterialName   string `json:"materialName"`
+	UnInspectedQty int    `json:"unInspectedQty"` // 未检数量（结构件=数量求和；电气件=SN 行数）
+	DetailsTotal   int    `json:"detailsTotal"`   // 未检批次数/SN 总数（抽屉分页拉明细）
+	InboundTime    int64  `json:"inboundTime"`
 }
 
 // pendingInspectionHandler 待检清单（来料检验问题2）：列出 quality_status=未检 的库存行，
@@ -769,9 +760,8 @@ func pendingInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 			}
 		}
 
-		// 物料名称/品类 map
+		// 物料名称 map
 		matName := map[string]string{}
-		matItemType := map[string]int{}
 		codeSet := []string{}
 		seenC := map[string]bool{}
 		for _, inv := range all {
@@ -784,7 +774,6 @@ func pendingInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 			if mats, e := ctx.EntClient.Material.Query().Where(material.CodeIn(codeSet...)).All(ctx0()); e == nil {
 				for _, m := range mats {
 					matName[m.Code] = m.Name
-					matItemType[m.Code] = m.ItemType
 				}
 			}
 		}
@@ -818,15 +807,7 @@ func pendingInspectionHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 				qty = inv.Quantity
 			}
 			g.UnInspectedQty += qty
-			g.BatchSnCount++
-			tid := inv.BatchNo
-			if inv.ManageMode == 2 {
-				tid = inv.SnCode
-			}
-			g.Details = append(g.Details, pendingInspectionItem{
-				ID: inv.ID, TargetId: tid, ManageMode: inv.ManageMode, ItemType: matItemType[inv.MaterialCode],
-				Quantity: inv.Quantity, ZoneCode: inv.ZoneCode,
-			})
+			g.DetailsTotal++
 			if o != nil && o.CreatedAt > g.InboundTime {
 				g.InboundTime = o.CreatedAt
 			}
@@ -856,3 +837,69 @@ func strOrEmpty(o *ent.InboundOrder) string {
 	}
 	return o.InboundType
 }
+
+// pendingDetailsInspectionHandler GET /api/inspection/pending/details
+// 待检清单主行抽屉里的明细分页（右侧抽屉懒加载，不再主行带 details 数组）。
+// 入参：inboundNo + materialCode + page + pageSize（默认 20）。
+func pendingDetailsInspectionHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		q := r.URL.Query()
+		inboundNo := q.Get("inboundNo")
+		materialCode := q.Get("materialCode")
+		if inboundNo == "" || materialCode == "" {
+			fail(w, http.StatusBadRequest, "inboundNo 和 materialCode 不能为空")
+			return
+		}
+		page, _ := strconv.Atoi(q.Get("page"))
+		pageSize, _ := strconv.Atoi(q.Get("pageSize"))
+		if page < 1 {
+			page = 1
+		}
+		if pageSize < 1 || pageSize > 500 {
+			pageSize = 20
+		}
+
+		qry := svcCtx.EntClient.Inventory.Query().
+			Where(
+				inventory.InboundNoEQ(inboundNo),
+				inventory.MaterialCodeEQ(materialCode),
+				inventory.QualityStatusEQ("未检"),
+			)
+		total, err := qry.Count(ctx0())
+		if err != nil {
+			fail(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+		start := (page - 1) * pageSize
+		list, err := qry.
+			Order(inventory.ByID()).
+			Offset(start).
+			Limit(pageSize).
+			All(ctx0())
+		if err != nil {
+			fail(w, http.StatusInternalServerError, err.Error())
+			return
+		}
+		// itemType 从物料档案补查（一个 materialCode 唯一）
+		itemType := 0
+		if m, e := svcCtx.EntClient.Material.Query().Where(material.CodeEQ(materialCode)).Only(ctx0()); e == nil {
+			itemType = m.ItemType
+		}
+		rows := make([]map[string]any, 0, len(list))
+		for _, inv := range list {
+			tid := inv.BatchNo
+			if inv.ManageMode == 2 {
+				tid = inv.SnCode
+			}
+			rows = append(rows, map[string]any{
+				"targetId":   tid,
+				"manageMode": inv.ManageMode,
+				"itemType":   itemType,
+				"quantity":   inv.Quantity,
+				"zoneCode":   inv.ZoneCode,
+				"id":         inv.ID,
+			})
+		}
+		ok(w, map[string]any{"list": rows, "total": total, "page": page, "pageSize": pageSize})
+	}
+}
diff --git a/bj_power_wms/internal/handler/outbound.go b/bj_power_wms/internal/handler/outbound.go
index ab806d1..7a61ede 100644
--- a/bj_power_wms/internal/handler/outbound.go
+++ b/bj_power_wms/internal/handler/outbound.go
@@ -13,7 +13,6 @@ import (
 	"bj_power_wms/ent/outboundorder"
 	"bj_power_wms/internal/svc"
 
-	"github.com/google/uuid"
 	"github.com/zeromicro/go-zero/core/logx"
 )
 
@@ -37,6 +36,7 @@ type deductStockRequest struct {
 	LayerNo      string   `json:"layerNo"`
 	PositionNo   string   `json:"positionNo"`
 	Remark       string   `json:"remark"`
+	OutboundNo   string   `json:"outboundNo"` // 可选：留空自动生成；填了必须唯一（如 OB20260921-001）
 	// OutboundType 出库类型：workorder(备料出库，默认) / refill(工位叫料·补料出库)
 	OutboundType string `json:"outboundType"`
 	// NeedAgv 是否需要 AGV 配送到接驳台（备料/补料一般为 true）
@@ -92,7 +92,20 @@ func deductStockHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 			return
 		}
 
-		outboundNo := "OB" + uuid.NewString()[:12]
+		outboundNo := strings.TrimSpace(req.OutboundNo)
+		if outboundNo != "" {
+			if err := validateUniqueNo(ctx, "OB", outboundNo); err != nil {
+				fail(w, http.StatusBadRequest, err.Error())
+				return
+			}
+		} else {
+			no, err := nextDailyNo(ctx, "OB")
+			if err != nil {
+				fail(w, http.StatusInternalServerError, "生成出库单号失败: "+err.Error())
+				return
+			}
+			outboundNo = no
+		}
 
 		// 开启事务：出库单 + 库存扣减 + 明细 + 台账 原子提交
 		tx, err := ctx.EntClient.Tx(ctx0())
@@ -316,6 +329,7 @@ func queryOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 		materialName := r.URL.Query().Get("materialName")
 		targetStation := r.URL.Query().Get("targetStation")
 		status := r.URL.Query().Get("status")
+		inspectionNo := r.URL.Query().Get("inspectionNo")
 
 		q := ctx.EntClient.OutboundOrder.Query()
 		if status != "" {
@@ -348,6 +362,9 @@ func queryOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 		if targetStation != "" {
 			q = q.Where(outboundorder.TargetStationEQ(targetStation))
 		}
+		if inspectionNo != "" {
+			q = q.Where(outboundorder.InspectionNoContainsFold(inspectionNo))
+		}
 		if v := r.URL.Query().Get("startDate"); v != "" {
 			if t, err := time.ParseInLocation("2006-01-02", v, time.Local); err == nil {
 				q = q.Where(outboundorder.CreatedAtGTE(t.Unix()))
@@ -409,7 +426,9 @@ type generalOutboundRequest struct {
 	BoxNo            string   `json:"boxNo"`
 	ContractNo       string   `json:"contractNo"`
 	Remark           string   `json:"remark"`
+	OutboundNo       string   `json:"outboundNo"`       // 可选：留空自动生成；填了必须唯一（如 OB20260921-001）
 	OutboundCategory string   `json:"outboundCategory"` // return(退料)/supplier_return(退货退供应商)/sample(样品)/scrap(报废)/deliver(发货)/other(其他)
+	InspectionNo     string   `json:"inspectionNo"`     // 可选：检测单号，退货/报废等需溯源检验单据
 	OwnershipType    string   `json:"ownershipType"`    // workorder/project/other
 	OwnershipNo      string   `json:"ownershipNo"`
 	TargetStation    string   `json:"targetStation"`
@@ -469,7 +488,20 @@ func generalOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 		req.ZoneCode, req.ShelfNo, req.LayerNo, req.PositionNo =
 			outboundLocationFallback(ctx, req.BatchNo, req.SnList, req.ZoneCode, req.ShelfNo, req.LayerNo, req.PositionNo)
 
-		outboundNo := "OB" + uuid.NewString()[:12]
+		outboundNo := strings.TrimSpace(req.OutboundNo)
+		if outboundNo != "" {
+			if err := validateUniqueNo(ctx, "OB", outboundNo); err != nil {
+				fail(w, http.StatusBadRequest, err.Error())
+				return
+			}
+		} else {
+			no, err := nextDailyNo(ctx, "OB")
+			if err != nil {
+				fail(w, http.StatusInternalServerError, "生成出库单号失败: "+err.Error())
+				return
+			}
+			outboundNo = no
+		}
 
 		tx, err := ctx.EntClient.Tx(ctx0())
 		if err != nil {
@@ -492,6 +524,7 @@ func generalOutboundHandler(ctx *svc.ServiceContext) http.HandlerFunc {
 			SetNillableOutboundCategory(strPtr(req.OutboundCategory)).
 			SetNillableOwnershipType(strPtr(req.OwnershipType)).
 			SetNillableOwnershipNo(strPtr(req.OwnershipNo)).
+			SetNillableInspectionNo(strPtr(req.InspectionNo)).
 			SetNillableTargetStation(strPtr(req.TargetStation)).
 			SetMaterialCode(req.MaterialCode).
 			SetManageMode(manageMode).
diff --git a/bj_power_wms/internal/handler/routes.go b/bj_power_wms/internal/handler/routes.go
index 8142b40..07032fe 100644
--- a/bj_power_wms/internal/handler/routes.go
+++ b/bj_power_wms/internal/handler/routes.go
@@ -133,6 +133,7 @@ func RegisterHandlers(server *rest.Server, ctx *svc.ServiceContext) {
 			{Method: http.MethodGet, Path: "/api/inspection/export", Handler: exportInspectionHandler(ctx)},
 			{Method: http.MethodGet, Path: "/api/inspection/stats", Handler: statsInspectionHandler(ctx)},
 			{Method: http.MethodGet, Path: "/api/inspection/pending", Handler: pendingInspectionHandler(ctx)},
+			{Method: http.MethodGet, Path: "/api/inspection/pending/details", Handler: pendingDetailsInspectionHandler(ctx)},
 		},
 	)
 
diff --git a/bj_power_wms/inventory/inventory.go b/bj_power_wms/inventory/inventory.go
new file mode 100644
index 0000000..5b680aa
--- /dev/null
+++ b/bj_power_wms/inventory/inventory.go
@@ -0,0 +1,316 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inventory
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the inventory type in the database.
+	Label = "inventory"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldManageMode holds the string denoting the manage_mode field in the database.
+	FieldManageMode = "manage_mode"
+	// FieldCategory holds the string denoting the category field in the database.
+	FieldCategory = "category"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldMaterialName holds the string denoting the material_name field in the database.
+	FieldMaterialName = "material_name"
+	// FieldBatchNo holds the string denoting the batch_no field in the database.
+	FieldBatchNo = "batch_no"
+	// FieldSnCode holds the string denoting the sn_code field in the database.
+	FieldSnCode = "sn_code"
+	// FieldQuantity holds the string denoting the quantity field in the database.
+	FieldQuantity = "quantity"
+	// FieldLockedQty holds the string denoting the locked_qty field in the database.
+	FieldLockedQty = "locked_qty"
+	// FieldQualityStatus holds the string denoting the quality_status field in the database.
+	FieldQualityStatus = "quality_status"
+	// FieldZoneCode holds the string denoting the zone_code field in the database.
+	FieldZoneCode = "zone_code"
+	// FieldShelfNo holds the string denoting the shelf_no field in the database.
+	FieldShelfNo = "shelf_no"
+	// FieldLayerNo holds the string denoting the layer_no field in the database.
+	FieldLayerNo = "layer_no"
+	// FieldPositionNo holds the string denoting the position_no field in the database.
+	FieldPositionNo = "position_no"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldProductionDate holds the string denoting the production_date field in the database.
+	FieldProductionDate = "production_date"
+	// FieldSupplier holds the string denoting the supplier field in the database.
+	FieldSupplier = "supplier"
+	// FieldInboundNo holds the string denoting the inbound_no field in the database.
+	FieldInboundNo = "inbound_no"
+	// FieldOrderNo holds the string denoting the order_no field in the database.
+	FieldOrderNo = "order_no"
+	// FieldCompletedProcess holds the string denoting the completed_process field in the database.
+	FieldCompletedProcess = "completed_process"
+	// FieldOwnershipType holds the string denoting the ownership_type field in the database.
+	FieldOwnershipType = "ownership_type"
+	// FieldOwnershipNo holds the string denoting the ownership_no field in the database.
+	FieldOwnershipNo = "ownership_no"
+	// FieldProductStatus holds the string denoting the product_status field in the database.
+	FieldProductStatus = "product_status"
+	// FieldRelatedStandard holds the string denoting the related_standard field in the database.
+	FieldRelatedStandard = "related_standard"
+	// FieldTestRecordNo holds the string denoting the test_record_no field in the database.
+	FieldTestRecordNo = "test_record_no"
+	// FieldRecordedBy holds the string denoting the recorded_by field in the database.
+	FieldRecordedBy = "recorded_by"
+	// FieldRecordedAt holds the string denoting the recorded_at field in the database.
+	FieldRecordedAt = "recorded_at"
+	// FieldOutboundReason holds the string denoting the outbound_reason field in the database.
+	FieldOutboundReason = "outbound_reason"
+	// FieldStocktakeNo holds the string denoting the stocktake_no field in the database.
+	FieldStocktakeNo = "stocktake_no"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the inventory in the database.
+	Table = "inventories"
+)
+
+// Columns holds all SQL columns for inventory fields.
+var Columns = []string{
+	FieldID,
+	FieldManageMode,
+	FieldCategory,
+	FieldMaterialCode,
+	FieldMaterialName,
+	FieldBatchNo,
+	FieldSnCode,
+	FieldQuantity,
+	FieldLockedQty,
+	FieldQualityStatus,
+	FieldZoneCode,
+	FieldShelfNo,
+	FieldLayerNo,
+	FieldPositionNo,
+	FieldStatus,
+	FieldProductionDate,
+	FieldSupplier,
+	FieldInboundNo,
+	FieldOrderNo,
+	FieldCompletedProcess,
+	FieldOwnershipType,
+	FieldOwnershipNo,
+	FieldProductStatus,
+	FieldRelatedStandard,
+	FieldTestRecordNo,
+	FieldRecordedBy,
+	FieldRecordedAt,
+	FieldOutboundReason,
+	FieldStocktakeNo,
+	FieldRemark,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultCategory holds the default value on creation for the "category" field.
+	DefaultCategory int
+	// DefaultQuantity holds the default value on creation for the "quantity" field.
+	DefaultQuantity int
+	// DefaultLockedQty holds the default value on creation for the "locked_qty" field.
+	DefaultLockedQty int
+	// DefaultQualityStatus holds the default value on creation for the "quality_status" field.
+	DefaultQualityStatus string
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultOrderNo holds the default value on creation for the "order_no" field.
+	DefaultOrderNo string
+	// OrderNoValidator is a validator for the "order_no" field. It is called by the builders before save.
+	OrderNoValidator func(string) error
+	// DefaultCompletedProcess holds the default value on creation for the "completed_process" field.
+	DefaultCompletedProcess string
+	// CompletedProcessValidator is a validator for the "completed_process" field. It is called by the builders before save.
+	CompletedProcessValidator func(string) error
+	// DefaultStocktakeNo holds the default value on creation for the "stocktake_no" field.
+	DefaultStocktakeNo string
+	// StocktakeNoValidator is a validator for the "stocktake_no" field. It is called by the builders before save.
+	StocktakeNoValidator func(string) error
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the Inventory queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByManageMode orders the results by the manage_mode field.
+func ByManageMode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldManageMode, opts...).ToFunc()
+}
+
+// ByCategory orders the results by the category field.
+func ByCategory(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCategory, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByMaterialName orders the results by the material_name field.
+func ByMaterialName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialName, opts...).ToFunc()
+}
+
+// ByBatchNo orders the results by the batch_no field.
+func ByBatchNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBatchNo, opts...).ToFunc()
+}
+
+// BySnCode orders the results by the sn_code field.
+func BySnCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSnCode, opts...).ToFunc()
+}
+
+// ByQuantity orders the results by the quantity field.
+func ByQuantity(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQuantity, opts...).ToFunc()
+}
+
+// ByLockedQty orders the results by the locked_qty field.
+func ByLockedQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLockedQty, opts...).ToFunc()
+}
+
+// ByQualityStatus orders the results by the quality_status field.
+func ByQualityStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQualityStatus, opts...).ToFunc()
+}
+
+// ByZoneCode orders the results by the zone_code field.
+func ByZoneCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldZoneCode, opts...).ToFunc()
+}
+
+// ByShelfNo orders the results by the shelf_no field.
+func ByShelfNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldShelfNo, opts...).ToFunc()
+}
+
+// ByLayerNo orders the results by the layer_no field.
+func ByLayerNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLayerNo, opts...).ToFunc()
+}
+
+// ByPositionNo orders the results by the position_no field.
+func ByPositionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPositionNo, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByProductionDate orders the results by the production_date field.
+func ByProductionDate(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldProductionDate, opts...).ToFunc()
+}
+
+// BySupplier orders the results by the supplier field.
+func BySupplier(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSupplier, opts...).ToFunc()
+}
+
+// ByInboundNo orders the results by the inbound_no field.
+func ByInboundNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInboundNo, opts...).ToFunc()
+}
+
+// ByOrderNo orders the results by the order_no field.
+func ByOrderNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOrderNo, opts...).ToFunc()
+}
+
+// ByCompletedProcess orders the results by the completed_process field.
+func ByCompletedProcess(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCompletedProcess, opts...).ToFunc()
+}
+
+// ByOwnershipType orders the results by the ownership_type field.
+func ByOwnershipType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOwnershipType, opts...).ToFunc()
+}
+
+// ByOwnershipNo orders the results by the ownership_no field.
+func ByOwnershipNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOwnershipNo, opts...).ToFunc()
+}
+
+// ByProductStatus orders the results by the product_status field.
+func ByProductStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldProductStatus, opts...).ToFunc()
+}
+
+// ByRelatedStandard orders the results by the related_standard field.
+func ByRelatedStandard(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRelatedStandard, opts...).ToFunc()
+}
+
+// ByTestRecordNo orders the results by the test_record_no field.
+func ByTestRecordNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTestRecordNo, opts...).ToFunc()
+}
+
+// ByRecordedBy orders the results by the recorded_by field.
+func ByRecordedBy(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRecordedBy, opts...).ToFunc()
+}
+
+// ByRecordedAt orders the results by the recorded_at field.
+func ByRecordedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRecordedAt, opts...).ToFunc()
+}
+
+// ByOutboundReason orders the results by the outbound_reason field.
+func ByOutboundReason(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOutboundReason, opts...).ToFunc()
+}
+
+// ByStocktakeNo orders the results by the stocktake_no field.
+func ByStocktakeNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStocktakeNo, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/inventory/where.go b/bj_power_wms/inventory/where.go
new file mode 100644
index 0000000..54da008
--- /dev/null
+++ b/bj_power_wms/inventory/where.go
@@ -0,0 +1,2254 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inventory
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldID, id))
+}
+
+// ManageMode applies equality check predicate on the "manage_mode" field. It's identical to ManageModeEQ.
+func ManageMode(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldManageMode, v))
+}
+
+// Category applies equality check predicate on the "category" field. It's identical to CategoryEQ.
+func Category(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldCategory, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialName applies equality check predicate on the "material_name" field. It's identical to MaterialNameEQ.
+func MaterialName(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// BatchNo applies equality check predicate on the "batch_no" field. It's identical to BatchNoEQ.
+func BatchNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// SnCode applies equality check predicate on the "sn_code" field. It's identical to SnCodeEQ.
+func SnCode(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldSnCode, v))
+}
+
+// Quantity applies equality check predicate on the "quantity" field. It's identical to QuantityEQ.
+func Quantity(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldQuantity, v))
+}
+
+// LockedQty applies equality check predicate on the "locked_qty" field. It's identical to LockedQtyEQ.
+func LockedQty(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldLockedQty, v))
+}
+
+// QualityStatus applies equality check predicate on the "quality_status" field. It's identical to QualityStatusEQ.
+func QualityStatus(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldQualityStatus, v))
+}
+
+// ZoneCode applies equality check predicate on the "zone_code" field. It's identical to ZoneCodeEQ.
+func ZoneCode(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ShelfNo applies equality check predicate on the "shelf_no" field. It's identical to ShelfNoEQ.
+func ShelfNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// LayerNo applies equality check predicate on the "layer_no" field. It's identical to LayerNoEQ.
+func LayerNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// PositionNo applies equality check predicate on the "position_no" field. It's identical to PositionNoEQ.
+func PositionNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldStatus, v))
+}
+
+// ProductionDate applies equality check predicate on the "production_date" field. It's identical to ProductionDateEQ.
+func ProductionDate(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldProductionDate, v))
+}
+
+// Supplier applies equality check predicate on the "supplier" field. It's identical to SupplierEQ.
+func Supplier(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldSupplier, v))
+}
+
+// InboundNo applies equality check predicate on the "inbound_no" field. It's identical to InboundNoEQ.
+func InboundNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldInboundNo, v))
+}
+
+// OrderNo applies equality check predicate on the "order_no" field. It's identical to OrderNoEQ.
+func OrderNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// CompletedProcess applies equality check predicate on the "completed_process" field. It's identical to CompletedProcessEQ.
+func CompletedProcess(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldCompletedProcess, v))
+}
+
+// OwnershipType applies equality check predicate on the "ownership_type" field. It's identical to OwnershipTypeEQ.
+func OwnershipType(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldOwnershipType, v))
+}
+
+// OwnershipNo applies equality check predicate on the "ownership_no" field. It's identical to OwnershipNoEQ.
+func OwnershipNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldOwnershipNo, v))
+}
+
+// ProductStatus applies equality check predicate on the "product_status" field. It's identical to ProductStatusEQ.
+func ProductStatus(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldProductStatus, v))
+}
+
+// RelatedStandard applies equality check predicate on the "related_standard" field. It's identical to RelatedStandardEQ.
+func RelatedStandard(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldRelatedStandard, v))
+}
+
+// TestRecordNo applies equality check predicate on the "test_record_no" field. It's identical to TestRecordNoEQ.
+func TestRecordNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldTestRecordNo, v))
+}
+
+// RecordedBy applies equality check predicate on the "recorded_by" field. It's identical to RecordedByEQ.
+func RecordedBy(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldRecordedBy, v))
+}
+
+// RecordedAt applies equality check predicate on the "recorded_at" field. It's identical to RecordedAtEQ.
+func RecordedAt(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldRecordedAt, v))
+}
+
+// OutboundReason applies equality check predicate on the "outbound_reason" field. It's identical to OutboundReasonEQ.
+func OutboundReason(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldOutboundReason, v))
+}
+
+// StocktakeNo applies equality check predicate on the "stocktake_no" field. It's identical to StocktakeNoEQ.
+func StocktakeNo(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldStocktakeNo, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldRemark, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// ManageModeEQ applies the EQ predicate on the "manage_mode" field.
+func ManageModeEQ(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldManageMode, v))
+}
+
+// ManageModeNEQ applies the NEQ predicate on the "manage_mode" field.
+func ManageModeNEQ(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldManageMode, v))
+}
+
+// ManageModeIn applies the In predicate on the "manage_mode" field.
+func ManageModeIn(vs ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldManageMode, vs...))
+}
+
+// ManageModeNotIn applies the NotIn predicate on the "manage_mode" field.
+func ManageModeNotIn(vs ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldManageMode, vs...))
+}
+
+// ManageModeGT applies the GT predicate on the "manage_mode" field.
+func ManageModeGT(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldManageMode, v))
+}
+
+// ManageModeGTE applies the GTE predicate on the "manage_mode" field.
+func ManageModeGTE(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldManageMode, v))
+}
+
+// ManageModeLT applies the LT predicate on the "manage_mode" field.
+func ManageModeLT(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldManageMode, v))
+}
+
+// ManageModeLTE applies the LTE predicate on the "manage_mode" field.
+func ManageModeLTE(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldManageMode, v))
+}
+
+// CategoryEQ applies the EQ predicate on the "category" field.
+func CategoryEQ(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldCategory, v))
+}
+
+// CategoryNEQ applies the NEQ predicate on the "category" field.
+func CategoryNEQ(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldCategory, v))
+}
+
+// CategoryIn applies the In predicate on the "category" field.
+func CategoryIn(vs ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldCategory, vs...))
+}
+
+// CategoryNotIn applies the NotIn predicate on the "category" field.
+func CategoryNotIn(vs ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldCategory, vs...))
+}
+
+// CategoryGT applies the GT predicate on the "category" field.
+func CategoryGT(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldCategory, v))
+}
+
+// CategoryGTE applies the GTE predicate on the "category" field.
+func CategoryGTE(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldCategory, v))
+}
+
+// CategoryLT applies the LT predicate on the "category" field.
+func CategoryLT(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldCategory, v))
+}
+
+// CategoryLTE applies the LTE predicate on the "category" field.
+func CategoryLTE(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldCategory, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// MaterialNameEQ applies the EQ predicate on the "material_name" field.
+func MaterialNameEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// MaterialNameNEQ applies the NEQ predicate on the "material_name" field.
+func MaterialNameNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldMaterialName, v))
+}
+
+// MaterialNameIn applies the In predicate on the "material_name" field.
+func MaterialNameIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameNotIn applies the NotIn predicate on the "material_name" field.
+func MaterialNameNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameGT applies the GT predicate on the "material_name" field.
+func MaterialNameGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldMaterialName, v))
+}
+
+// MaterialNameGTE applies the GTE predicate on the "material_name" field.
+func MaterialNameGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldMaterialName, v))
+}
+
+// MaterialNameLT applies the LT predicate on the "material_name" field.
+func MaterialNameLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldMaterialName, v))
+}
+
+// MaterialNameLTE applies the LTE predicate on the "material_name" field.
+func MaterialNameLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldMaterialName, v))
+}
+
+// MaterialNameContains applies the Contains predicate on the "material_name" field.
+func MaterialNameContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldMaterialName, v))
+}
+
+// MaterialNameHasPrefix applies the HasPrefix predicate on the "material_name" field.
+func MaterialNameHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldMaterialName, v))
+}
+
+// MaterialNameHasSuffix applies the HasSuffix predicate on the "material_name" field.
+func MaterialNameHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldMaterialName, v))
+}
+
+// MaterialNameIsNil applies the IsNil predicate on the "material_name" field.
+func MaterialNameIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldMaterialName))
+}
+
+// MaterialNameNotNil applies the NotNil predicate on the "material_name" field.
+func MaterialNameNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldMaterialName))
+}
+
+// MaterialNameEqualFold applies the EqualFold predicate on the "material_name" field.
+func MaterialNameEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldMaterialName, v))
+}
+
+// MaterialNameContainsFold applies the ContainsFold predicate on the "material_name" field.
+func MaterialNameContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldMaterialName, v))
+}
+
+// BatchNoEQ applies the EQ predicate on the "batch_no" field.
+func BatchNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// BatchNoNEQ applies the NEQ predicate on the "batch_no" field.
+func BatchNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldBatchNo, v))
+}
+
+// BatchNoIn applies the In predicate on the "batch_no" field.
+func BatchNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldBatchNo, vs...))
+}
+
+// BatchNoNotIn applies the NotIn predicate on the "batch_no" field.
+func BatchNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldBatchNo, vs...))
+}
+
+// BatchNoGT applies the GT predicate on the "batch_no" field.
+func BatchNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldBatchNo, v))
+}
+
+// BatchNoGTE applies the GTE predicate on the "batch_no" field.
+func BatchNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldBatchNo, v))
+}
+
+// BatchNoLT applies the LT predicate on the "batch_no" field.
+func BatchNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldBatchNo, v))
+}
+
+// BatchNoLTE applies the LTE predicate on the "batch_no" field.
+func BatchNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldBatchNo, v))
+}
+
+// BatchNoContains applies the Contains predicate on the "batch_no" field.
+func BatchNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldBatchNo, v))
+}
+
+// BatchNoHasPrefix applies the HasPrefix predicate on the "batch_no" field.
+func BatchNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldBatchNo, v))
+}
+
+// BatchNoHasSuffix applies the HasSuffix predicate on the "batch_no" field.
+func BatchNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldBatchNo, v))
+}
+
+// BatchNoIsNil applies the IsNil predicate on the "batch_no" field.
+func BatchNoIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldBatchNo))
+}
+
+// BatchNoNotNil applies the NotNil predicate on the "batch_no" field.
+func BatchNoNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldBatchNo))
+}
+
+// BatchNoEqualFold applies the EqualFold predicate on the "batch_no" field.
+func BatchNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldBatchNo, v))
+}
+
+// BatchNoContainsFold applies the ContainsFold predicate on the "batch_no" field.
+func BatchNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldBatchNo, v))
+}
+
+// SnCodeEQ applies the EQ predicate on the "sn_code" field.
+func SnCodeEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldSnCode, v))
+}
+
+// SnCodeNEQ applies the NEQ predicate on the "sn_code" field.
+func SnCodeNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldSnCode, v))
+}
+
+// SnCodeIn applies the In predicate on the "sn_code" field.
+func SnCodeIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldSnCode, vs...))
+}
+
+// SnCodeNotIn applies the NotIn predicate on the "sn_code" field.
+func SnCodeNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldSnCode, vs...))
+}
+
+// SnCodeGT applies the GT predicate on the "sn_code" field.
+func SnCodeGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldSnCode, v))
+}
+
+// SnCodeGTE applies the GTE predicate on the "sn_code" field.
+func SnCodeGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldSnCode, v))
+}
+
+// SnCodeLT applies the LT predicate on the "sn_code" field.
+func SnCodeLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldSnCode, v))
+}
+
+// SnCodeLTE applies the LTE predicate on the "sn_code" field.
+func SnCodeLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldSnCode, v))
+}
+
+// SnCodeContains applies the Contains predicate on the "sn_code" field.
+func SnCodeContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldSnCode, v))
+}
+
+// SnCodeHasPrefix applies the HasPrefix predicate on the "sn_code" field.
+func SnCodeHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldSnCode, v))
+}
+
+// SnCodeHasSuffix applies the HasSuffix predicate on the "sn_code" field.
+func SnCodeHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldSnCode, v))
+}
+
+// SnCodeIsNil applies the IsNil predicate on the "sn_code" field.
+func SnCodeIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldSnCode))
+}
+
+// SnCodeNotNil applies the NotNil predicate on the "sn_code" field.
+func SnCodeNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldSnCode))
+}
+
+// SnCodeEqualFold applies the EqualFold predicate on the "sn_code" field.
+func SnCodeEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldSnCode, v))
+}
+
+// SnCodeContainsFold applies the ContainsFold predicate on the "sn_code" field.
+func SnCodeContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldSnCode, v))
+}
+
+// QuantityEQ applies the EQ predicate on the "quantity" field.
+func QuantityEQ(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldQuantity, v))
+}
+
+// QuantityNEQ applies the NEQ predicate on the "quantity" field.
+func QuantityNEQ(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldQuantity, v))
+}
+
+// QuantityIn applies the In predicate on the "quantity" field.
+func QuantityIn(vs ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldQuantity, vs...))
+}
+
+// QuantityNotIn applies the NotIn predicate on the "quantity" field.
+func QuantityNotIn(vs ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldQuantity, vs...))
+}
+
+// QuantityGT applies the GT predicate on the "quantity" field.
+func QuantityGT(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldQuantity, v))
+}
+
+// QuantityGTE applies the GTE predicate on the "quantity" field.
+func QuantityGTE(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldQuantity, v))
+}
+
+// QuantityLT applies the LT predicate on the "quantity" field.
+func QuantityLT(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldQuantity, v))
+}
+
+// QuantityLTE applies the LTE predicate on the "quantity" field.
+func QuantityLTE(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldQuantity, v))
+}
+
+// LockedQtyEQ applies the EQ predicate on the "locked_qty" field.
+func LockedQtyEQ(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldLockedQty, v))
+}
+
+// LockedQtyNEQ applies the NEQ predicate on the "locked_qty" field.
+func LockedQtyNEQ(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldLockedQty, v))
+}
+
+// LockedQtyIn applies the In predicate on the "locked_qty" field.
+func LockedQtyIn(vs ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldLockedQty, vs...))
+}
+
+// LockedQtyNotIn applies the NotIn predicate on the "locked_qty" field.
+func LockedQtyNotIn(vs ...int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldLockedQty, vs...))
+}
+
+// LockedQtyGT applies the GT predicate on the "locked_qty" field.
+func LockedQtyGT(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldLockedQty, v))
+}
+
+// LockedQtyGTE applies the GTE predicate on the "locked_qty" field.
+func LockedQtyGTE(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldLockedQty, v))
+}
+
+// LockedQtyLT applies the LT predicate on the "locked_qty" field.
+func LockedQtyLT(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldLockedQty, v))
+}
+
+// LockedQtyLTE applies the LTE predicate on the "locked_qty" field.
+func LockedQtyLTE(v int) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldLockedQty, v))
+}
+
+// QualityStatusEQ applies the EQ predicate on the "quality_status" field.
+func QualityStatusEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldQualityStatus, v))
+}
+
+// QualityStatusNEQ applies the NEQ predicate on the "quality_status" field.
+func QualityStatusNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldQualityStatus, v))
+}
+
+// QualityStatusIn applies the In predicate on the "quality_status" field.
+func QualityStatusIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldQualityStatus, vs...))
+}
+
+// QualityStatusNotIn applies the NotIn predicate on the "quality_status" field.
+func QualityStatusNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldQualityStatus, vs...))
+}
+
+// QualityStatusGT applies the GT predicate on the "quality_status" field.
+func QualityStatusGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldQualityStatus, v))
+}
+
+// QualityStatusGTE applies the GTE predicate on the "quality_status" field.
+func QualityStatusGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldQualityStatus, v))
+}
+
+// QualityStatusLT applies the LT predicate on the "quality_status" field.
+func QualityStatusLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldQualityStatus, v))
+}
+
+// QualityStatusLTE applies the LTE predicate on the "quality_status" field.
+func QualityStatusLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldQualityStatus, v))
+}
+
+// QualityStatusContains applies the Contains predicate on the "quality_status" field.
+func QualityStatusContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldQualityStatus, v))
+}
+
+// QualityStatusHasPrefix applies the HasPrefix predicate on the "quality_status" field.
+func QualityStatusHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldQualityStatus, v))
+}
+
+// QualityStatusHasSuffix applies the HasSuffix predicate on the "quality_status" field.
+func QualityStatusHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldQualityStatus, v))
+}
+
+// QualityStatusEqualFold applies the EqualFold predicate on the "quality_status" field.
+func QualityStatusEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldQualityStatus, v))
+}
+
+// QualityStatusContainsFold applies the ContainsFold predicate on the "quality_status" field.
+func QualityStatusContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldQualityStatus, v))
+}
+
+// ZoneCodeEQ applies the EQ predicate on the "zone_code" field.
+func ZoneCodeEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeNEQ applies the NEQ predicate on the "zone_code" field.
+func ZoneCodeNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeIn applies the In predicate on the "zone_code" field.
+func ZoneCodeIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeNotIn applies the NotIn predicate on the "zone_code" field.
+func ZoneCodeNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeGT applies the GT predicate on the "zone_code" field.
+func ZoneCodeGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldZoneCode, v))
+}
+
+// ZoneCodeGTE applies the GTE predicate on the "zone_code" field.
+func ZoneCodeGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldZoneCode, v))
+}
+
+// ZoneCodeLT applies the LT predicate on the "zone_code" field.
+func ZoneCodeLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldZoneCode, v))
+}
+
+// ZoneCodeLTE applies the LTE predicate on the "zone_code" field.
+func ZoneCodeLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldZoneCode, v))
+}
+
+// ZoneCodeContains applies the Contains predicate on the "zone_code" field.
+func ZoneCodeContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldZoneCode, v))
+}
+
+// ZoneCodeHasPrefix applies the HasPrefix predicate on the "zone_code" field.
+func ZoneCodeHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldZoneCode, v))
+}
+
+// ZoneCodeHasSuffix applies the HasSuffix predicate on the "zone_code" field.
+func ZoneCodeHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldZoneCode, v))
+}
+
+// ZoneCodeIsNil applies the IsNil predicate on the "zone_code" field.
+func ZoneCodeIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldZoneCode))
+}
+
+// ZoneCodeNotNil applies the NotNil predicate on the "zone_code" field.
+func ZoneCodeNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldZoneCode))
+}
+
+// ZoneCodeEqualFold applies the EqualFold predicate on the "zone_code" field.
+func ZoneCodeEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldZoneCode, v))
+}
+
+// ZoneCodeContainsFold applies the ContainsFold predicate on the "zone_code" field.
+func ZoneCodeContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldZoneCode, v))
+}
+
+// ShelfNoEQ applies the EQ predicate on the "shelf_no" field.
+func ShelfNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// ShelfNoNEQ applies the NEQ predicate on the "shelf_no" field.
+func ShelfNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldShelfNo, v))
+}
+
+// ShelfNoIn applies the In predicate on the "shelf_no" field.
+func ShelfNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoNotIn applies the NotIn predicate on the "shelf_no" field.
+func ShelfNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoGT applies the GT predicate on the "shelf_no" field.
+func ShelfNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldShelfNo, v))
+}
+
+// ShelfNoGTE applies the GTE predicate on the "shelf_no" field.
+func ShelfNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldShelfNo, v))
+}
+
+// ShelfNoLT applies the LT predicate on the "shelf_no" field.
+func ShelfNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldShelfNo, v))
+}
+
+// ShelfNoLTE applies the LTE predicate on the "shelf_no" field.
+func ShelfNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldShelfNo, v))
+}
+
+// ShelfNoContains applies the Contains predicate on the "shelf_no" field.
+func ShelfNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldShelfNo, v))
+}
+
+// ShelfNoHasPrefix applies the HasPrefix predicate on the "shelf_no" field.
+func ShelfNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldShelfNo, v))
+}
+
+// ShelfNoHasSuffix applies the HasSuffix predicate on the "shelf_no" field.
+func ShelfNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldShelfNo, v))
+}
+
+// ShelfNoIsNil applies the IsNil predicate on the "shelf_no" field.
+func ShelfNoIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldShelfNo))
+}
+
+// ShelfNoNotNil applies the NotNil predicate on the "shelf_no" field.
+func ShelfNoNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldShelfNo))
+}
+
+// ShelfNoEqualFold applies the EqualFold predicate on the "shelf_no" field.
+func ShelfNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldShelfNo, v))
+}
+
+// ShelfNoContainsFold applies the ContainsFold predicate on the "shelf_no" field.
+func ShelfNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldShelfNo, v))
+}
+
+// LayerNoEQ applies the EQ predicate on the "layer_no" field.
+func LayerNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// LayerNoNEQ applies the NEQ predicate on the "layer_no" field.
+func LayerNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldLayerNo, v))
+}
+
+// LayerNoIn applies the In predicate on the "layer_no" field.
+func LayerNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldLayerNo, vs...))
+}
+
+// LayerNoNotIn applies the NotIn predicate on the "layer_no" field.
+func LayerNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldLayerNo, vs...))
+}
+
+// LayerNoGT applies the GT predicate on the "layer_no" field.
+func LayerNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldLayerNo, v))
+}
+
+// LayerNoGTE applies the GTE predicate on the "layer_no" field.
+func LayerNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldLayerNo, v))
+}
+
+// LayerNoLT applies the LT predicate on the "layer_no" field.
+func LayerNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldLayerNo, v))
+}
+
+// LayerNoLTE applies the LTE predicate on the "layer_no" field.
+func LayerNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldLayerNo, v))
+}
+
+// LayerNoContains applies the Contains predicate on the "layer_no" field.
+func LayerNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldLayerNo, v))
+}
+
+// LayerNoHasPrefix applies the HasPrefix predicate on the "layer_no" field.
+func LayerNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldLayerNo, v))
+}
+
+// LayerNoHasSuffix applies the HasSuffix predicate on the "layer_no" field.
+func LayerNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldLayerNo, v))
+}
+
+// LayerNoIsNil applies the IsNil predicate on the "layer_no" field.
+func LayerNoIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldLayerNo))
+}
+
+// LayerNoNotNil applies the NotNil predicate on the "layer_no" field.
+func LayerNoNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldLayerNo))
+}
+
+// LayerNoEqualFold applies the EqualFold predicate on the "layer_no" field.
+func LayerNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldLayerNo, v))
+}
+
+// LayerNoContainsFold applies the ContainsFold predicate on the "layer_no" field.
+func LayerNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldLayerNo, v))
+}
+
+// PositionNoEQ applies the EQ predicate on the "position_no" field.
+func PositionNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// PositionNoNEQ applies the NEQ predicate on the "position_no" field.
+func PositionNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldPositionNo, v))
+}
+
+// PositionNoIn applies the In predicate on the "position_no" field.
+func PositionNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldPositionNo, vs...))
+}
+
+// PositionNoNotIn applies the NotIn predicate on the "position_no" field.
+func PositionNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldPositionNo, vs...))
+}
+
+// PositionNoGT applies the GT predicate on the "position_no" field.
+func PositionNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldPositionNo, v))
+}
+
+// PositionNoGTE applies the GTE predicate on the "position_no" field.
+func PositionNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldPositionNo, v))
+}
+
+// PositionNoLT applies the LT predicate on the "position_no" field.
+func PositionNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldPositionNo, v))
+}
+
+// PositionNoLTE applies the LTE predicate on the "position_no" field.
+func PositionNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldPositionNo, v))
+}
+
+// PositionNoContains applies the Contains predicate on the "position_no" field.
+func PositionNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldPositionNo, v))
+}
+
+// PositionNoHasPrefix applies the HasPrefix predicate on the "position_no" field.
+func PositionNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldPositionNo, v))
+}
+
+// PositionNoHasSuffix applies the HasSuffix predicate on the "position_no" field.
+func PositionNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldPositionNo, v))
+}
+
+// PositionNoIsNil applies the IsNil predicate on the "position_no" field.
+func PositionNoIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldPositionNo))
+}
+
+// PositionNoNotNil applies the NotNil predicate on the "position_no" field.
+func PositionNoNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldPositionNo))
+}
+
+// PositionNoEqualFold applies the EqualFold predicate on the "position_no" field.
+func PositionNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldPositionNo, v))
+}
+
+// PositionNoContainsFold applies the ContainsFold predicate on the "position_no" field.
+func PositionNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldPositionNo, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// ProductionDateEQ applies the EQ predicate on the "production_date" field.
+func ProductionDateEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldProductionDate, v))
+}
+
+// ProductionDateNEQ applies the NEQ predicate on the "production_date" field.
+func ProductionDateNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldProductionDate, v))
+}
+
+// ProductionDateIn applies the In predicate on the "production_date" field.
+func ProductionDateIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldProductionDate, vs...))
+}
+
+// ProductionDateNotIn applies the NotIn predicate on the "production_date" field.
+func ProductionDateNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldProductionDate, vs...))
+}
+
+// ProductionDateGT applies the GT predicate on the "production_date" field.
+func ProductionDateGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldProductionDate, v))
+}
+
+// ProductionDateGTE applies the GTE predicate on the "production_date" field.
+func ProductionDateGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldProductionDate, v))
+}
+
+// ProductionDateLT applies the LT predicate on the "production_date" field.
+func ProductionDateLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldProductionDate, v))
+}
+
+// ProductionDateLTE applies the LTE predicate on the "production_date" field.
+func ProductionDateLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldProductionDate, v))
+}
+
+// ProductionDateContains applies the Contains predicate on the "production_date" field.
+func ProductionDateContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldProductionDate, v))
+}
+
+// ProductionDateHasPrefix applies the HasPrefix predicate on the "production_date" field.
+func ProductionDateHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldProductionDate, v))
+}
+
+// ProductionDateHasSuffix applies the HasSuffix predicate on the "production_date" field.
+func ProductionDateHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldProductionDate, v))
+}
+
+// ProductionDateIsNil applies the IsNil predicate on the "production_date" field.
+func ProductionDateIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldProductionDate))
+}
+
+// ProductionDateNotNil applies the NotNil predicate on the "production_date" field.
+func ProductionDateNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldProductionDate))
+}
+
+// ProductionDateEqualFold applies the EqualFold predicate on the "production_date" field.
+func ProductionDateEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldProductionDate, v))
+}
+
+// ProductionDateContainsFold applies the ContainsFold predicate on the "production_date" field.
+func ProductionDateContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldProductionDate, v))
+}
+
+// SupplierEQ applies the EQ predicate on the "supplier" field.
+func SupplierEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldSupplier, v))
+}
+
+// SupplierNEQ applies the NEQ predicate on the "supplier" field.
+func SupplierNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldSupplier, v))
+}
+
+// SupplierIn applies the In predicate on the "supplier" field.
+func SupplierIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldSupplier, vs...))
+}
+
+// SupplierNotIn applies the NotIn predicate on the "supplier" field.
+func SupplierNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldSupplier, vs...))
+}
+
+// SupplierGT applies the GT predicate on the "supplier" field.
+func SupplierGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldSupplier, v))
+}
+
+// SupplierGTE applies the GTE predicate on the "supplier" field.
+func SupplierGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldSupplier, v))
+}
+
+// SupplierLT applies the LT predicate on the "supplier" field.
+func SupplierLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldSupplier, v))
+}
+
+// SupplierLTE applies the LTE predicate on the "supplier" field.
+func SupplierLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldSupplier, v))
+}
+
+// SupplierContains applies the Contains predicate on the "supplier" field.
+func SupplierContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldSupplier, v))
+}
+
+// SupplierHasPrefix applies the HasPrefix predicate on the "supplier" field.
+func SupplierHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldSupplier, v))
+}
+
+// SupplierHasSuffix applies the HasSuffix predicate on the "supplier" field.
+func SupplierHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldSupplier, v))
+}
+
+// SupplierIsNil applies the IsNil predicate on the "supplier" field.
+func SupplierIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldSupplier))
+}
+
+// SupplierNotNil applies the NotNil predicate on the "supplier" field.
+func SupplierNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldSupplier))
+}
+
+// SupplierEqualFold applies the EqualFold predicate on the "supplier" field.
+func SupplierEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldSupplier, v))
+}
+
+// SupplierContainsFold applies the ContainsFold predicate on the "supplier" field.
+func SupplierContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldSupplier, v))
+}
+
+// InboundNoEQ applies the EQ predicate on the "inbound_no" field.
+func InboundNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldInboundNo, v))
+}
+
+// InboundNoNEQ applies the NEQ predicate on the "inbound_no" field.
+func InboundNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldInboundNo, v))
+}
+
+// InboundNoIn applies the In predicate on the "inbound_no" field.
+func InboundNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldInboundNo, vs...))
+}
+
+// InboundNoNotIn applies the NotIn predicate on the "inbound_no" field.
+func InboundNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldInboundNo, vs...))
+}
+
+// InboundNoGT applies the GT predicate on the "inbound_no" field.
+func InboundNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldInboundNo, v))
+}
+
+// InboundNoGTE applies the GTE predicate on the "inbound_no" field.
+func InboundNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldInboundNo, v))
+}
+
+// InboundNoLT applies the LT predicate on the "inbound_no" field.
+func InboundNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldInboundNo, v))
+}
+
+// InboundNoLTE applies the LTE predicate on the "inbound_no" field.
+func InboundNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldInboundNo, v))
+}
+
+// InboundNoContains applies the Contains predicate on the "inbound_no" field.
+func InboundNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldInboundNo, v))
+}
+
+// InboundNoHasPrefix applies the HasPrefix predicate on the "inbound_no" field.
+func InboundNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldInboundNo, v))
+}
+
+// InboundNoHasSuffix applies the HasSuffix predicate on the "inbound_no" field.
+func InboundNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldInboundNo, v))
+}
+
+// InboundNoIsNil applies the IsNil predicate on the "inbound_no" field.
+func InboundNoIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldInboundNo))
+}
+
+// InboundNoNotNil applies the NotNil predicate on the "inbound_no" field.
+func InboundNoNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldInboundNo))
+}
+
+// InboundNoEqualFold applies the EqualFold predicate on the "inbound_no" field.
+func InboundNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldInboundNo, v))
+}
+
+// InboundNoContainsFold applies the ContainsFold predicate on the "inbound_no" field.
+func InboundNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldInboundNo, v))
+}
+
+// OrderNoEQ applies the EQ predicate on the "order_no" field.
+func OrderNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// OrderNoNEQ applies the NEQ predicate on the "order_no" field.
+func OrderNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldOrderNo, v))
+}
+
+// OrderNoIn applies the In predicate on the "order_no" field.
+func OrderNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldOrderNo, vs...))
+}
+
+// OrderNoNotIn applies the NotIn predicate on the "order_no" field.
+func OrderNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldOrderNo, vs...))
+}
+
+// OrderNoGT applies the GT predicate on the "order_no" field.
+func OrderNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldOrderNo, v))
+}
+
+// OrderNoGTE applies the GTE predicate on the "order_no" field.
+func OrderNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldOrderNo, v))
+}
+
+// OrderNoLT applies the LT predicate on the "order_no" field.
+func OrderNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldOrderNo, v))
+}
+
+// OrderNoLTE applies the LTE predicate on the "order_no" field.
+func OrderNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldOrderNo, v))
+}
+
+// OrderNoContains applies the Contains predicate on the "order_no" field.
+func OrderNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldOrderNo, v))
+}
+
+// OrderNoHasPrefix applies the HasPrefix predicate on the "order_no" field.
+func OrderNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldOrderNo, v))
+}
+
+// OrderNoHasSuffix applies the HasSuffix predicate on the "order_no" field.
+func OrderNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldOrderNo, v))
+}
+
+// OrderNoEqualFold applies the EqualFold predicate on the "order_no" field.
+func OrderNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldOrderNo, v))
+}
+
+// OrderNoContainsFold applies the ContainsFold predicate on the "order_no" field.
+func OrderNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldOrderNo, v))
+}
+
+// CompletedProcessEQ applies the EQ predicate on the "completed_process" field.
+func CompletedProcessEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldCompletedProcess, v))
+}
+
+// CompletedProcessNEQ applies the NEQ predicate on the "completed_process" field.
+func CompletedProcessNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldCompletedProcess, v))
+}
+
+// CompletedProcessIn applies the In predicate on the "completed_process" field.
+func CompletedProcessIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldCompletedProcess, vs...))
+}
+
+// CompletedProcessNotIn applies the NotIn predicate on the "completed_process" field.
+func CompletedProcessNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldCompletedProcess, vs...))
+}
+
+// CompletedProcessGT applies the GT predicate on the "completed_process" field.
+func CompletedProcessGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldCompletedProcess, v))
+}
+
+// CompletedProcessGTE applies the GTE predicate on the "completed_process" field.
+func CompletedProcessGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldCompletedProcess, v))
+}
+
+// CompletedProcessLT applies the LT predicate on the "completed_process" field.
+func CompletedProcessLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldCompletedProcess, v))
+}
+
+// CompletedProcessLTE applies the LTE predicate on the "completed_process" field.
+func CompletedProcessLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldCompletedProcess, v))
+}
+
+// CompletedProcessContains applies the Contains predicate on the "completed_process" field.
+func CompletedProcessContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldCompletedProcess, v))
+}
+
+// CompletedProcessHasPrefix applies the HasPrefix predicate on the "completed_process" field.
+func CompletedProcessHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldCompletedProcess, v))
+}
+
+// CompletedProcessHasSuffix applies the HasSuffix predicate on the "completed_process" field.
+func CompletedProcessHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldCompletedProcess, v))
+}
+
+// CompletedProcessEqualFold applies the EqualFold predicate on the "completed_process" field.
+func CompletedProcessEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldCompletedProcess, v))
+}
+
+// CompletedProcessContainsFold applies the ContainsFold predicate on the "completed_process" field.
+func CompletedProcessContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldCompletedProcess, v))
+}
+
+// OwnershipTypeEQ applies the EQ predicate on the "ownership_type" field.
+func OwnershipTypeEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldOwnershipType, v))
+}
+
+// OwnershipTypeNEQ applies the NEQ predicate on the "ownership_type" field.
+func OwnershipTypeNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldOwnershipType, v))
+}
+
+// OwnershipTypeIn applies the In predicate on the "ownership_type" field.
+func OwnershipTypeIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldOwnershipType, vs...))
+}
+
+// OwnershipTypeNotIn applies the NotIn predicate on the "ownership_type" field.
+func OwnershipTypeNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldOwnershipType, vs...))
+}
+
+// OwnershipTypeGT applies the GT predicate on the "ownership_type" field.
+func OwnershipTypeGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldOwnershipType, v))
+}
+
+// OwnershipTypeGTE applies the GTE predicate on the "ownership_type" field.
+func OwnershipTypeGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldOwnershipType, v))
+}
+
+// OwnershipTypeLT applies the LT predicate on the "ownership_type" field.
+func OwnershipTypeLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldOwnershipType, v))
+}
+
+// OwnershipTypeLTE applies the LTE predicate on the "ownership_type" field.
+func OwnershipTypeLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldOwnershipType, v))
+}
+
+// OwnershipTypeContains applies the Contains predicate on the "ownership_type" field.
+func OwnershipTypeContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldOwnershipType, v))
+}
+
+// OwnershipTypeHasPrefix applies the HasPrefix predicate on the "ownership_type" field.
+func OwnershipTypeHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldOwnershipType, v))
+}
+
+// OwnershipTypeHasSuffix applies the HasSuffix predicate on the "ownership_type" field.
+func OwnershipTypeHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldOwnershipType, v))
+}
+
+// OwnershipTypeIsNil applies the IsNil predicate on the "ownership_type" field.
+func OwnershipTypeIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldOwnershipType))
+}
+
+// OwnershipTypeNotNil applies the NotNil predicate on the "ownership_type" field.
+func OwnershipTypeNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldOwnershipType))
+}
+
+// OwnershipTypeEqualFold applies the EqualFold predicate on the "ownership_type" field.
+func OwnershipTypeEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldOwnershipType, v))
+}
+
+// OwnershipTypeContainsFold applies the ContainsFold predicate on the "ownership_type" field.
+func OwnershipTypeContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldOwnershipType, v))
+}
+
+// OwnershipNoEQ applies the EQ predicate on the "ownership_no" field.
+func OwnershipNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldOwnershipNo, v))
+}
+
+// OwnershipNoNEQ applies the NEQ predicate on the "ownership_no" field.
+func OwnershipNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldOwnershipNo, v))
+}
+
+// OwnershipNoIn applies the In predicate on the "ownership_no" field.
+func OwnershipNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldOwnershipNo, vs...))
+}
+
+// OwnershipNoNotIn applies the NotIn predicate on the "ownership_no" field.
+func OwnershipNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldOwnershipNo, vs...))
+}
+
+// OwnershipNoGT applies the GT predicate on the "ownership_no" field.
+func OwnershipNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldOwnershipNo, v))
+}
+
+// OwnershipNoGTE applies the GTE predicate on the "ownership_no" field.
+func OwnershipNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldOwnershipNo, v))
+}
+
+// OwnershipNoLT applies the LT predicate on the "ownership_no" field.
+func OwnershipNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldOwnershipNo, v))
+}
+
+// OwnershipNoLTE applies the LTE predicate on the "ownership_no" field.
+func OwnershipNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldOwnershipNo, v))
+}
+
+// OwnershipNoContains applies the Contains predicate on the "ownership_no" field.
+func OwnershipNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldOwnershipNo, v))
+}
+
+// OwnershipNoHasPrefix applies the HasPrefix predicate on the "ownership_no" field.
+func OwnershipNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldOwnershipNo, v))
+}
+
+// OwnershipNoHasSuffix applies the HasSuffix predicate on the "ownership_no" field.
+func OwnershipNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldOwnershipNo, v))
+}
+
+// OwnershipNoIsNil applies the IsNil predicate on the "ownership_no" field.
+func OwnershipNoIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldOwnershipNo))
+}
+
+// OwnershipNoNotNil applies the NotNil predicate on the "ownership_no" field.
+func OwnershipNoNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldOwnershipNo))
+}
+
+// OwnershipNoEqualFold applies the EqualFold predicate on the "ownership_no" field.
+func OwnershipNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldOwnershipNo, v))
+}
+
+// OwnershipNoContainsFold applies the ContainsFold predicate on the "ownership_no" field.
+func OwnershipNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldOwnershipNo, v))
+}
+
+// ProductStatusEQ applies the EQ predicate on the "product_status" field.
+func ProductStatusEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldProductStatus, v))
+}
+
+// ProductStatusNEQ applies the NEQ predicate on the "product_status" field.
+func ProductStatusNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldProductStatus, v))
+}
+
+// ProductStatusIn applies the In predicate on the "product_status" field.
+func ProductStatusIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldProductStatus, vs...))
+}
+
+// ProductStatusNotIn applies the NotIn predicate on the "product_status" field.
+func ProductStatusNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldProductStatus, vs...))
+}
+
+// ProductStatusGT applies the GT predicate on the "product_status" field.
+func ProductStatusGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldProductStatus, v))
+}
+
+// ProductStatusGTE applies the GTE predicate on the "product_status" field.
+func ProductStatusGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldProductStatus, v))
+}
+
+// ProductStatusLT applies the LT predicate on the "product_status" field.
+func ProductStatusLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldProductStatus, v))
+}
+
+// ProductStatusLTE applies the LTE predicate on the "product_status" field.
+func ProductStatusLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldProductStatus, v))
+}
+
+// ProductStatusContains applies the Contains predicate on the "product_status" field.
+func ProductStatusContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldProductStatus, v))
+}
+
+// ProductStatusHasPrefix applies the HasPrefix predicate on the "product_status" field.
+func ProductStatusHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldProductStatus, v))
+}
+
+// ProductStatusHasSuffix applies the HasSuffix predicate on the "product_status" field.
+func ProductStatusHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldProductStatus, v))
+}
+
+// ProductStatusIsNil applies the IsNil predicate on the "product_status" field.
+func ProductStatusIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldProductStatus))
+}
+
+// ProductStatusNotNil applies the NotNil predicate on the "product_status" field.
+func ProductStatusNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldProductStatus))
+}
+
+// ProductStatusEqualFold applies the EqualFold predicate on the "product_status" field.
+func ProductStatusEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldProductStatus, v))
+}
+
+// ProductStatusContainsFold applies the ContainsFold predicate on the "product_status" field.
+func ProductStatusContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldProductStatus, v))
+}
+
+// RelatedStandardEQ applies the EQ predicate on the "related_standard" field.
+func RelatedStandardEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldRelatedStandard, v))
+}
+
+// RelatedStandardNEQ applies the NEQ predicate on the "related_standard" field.
+func RelatedStandardNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldRelatedStandard, v))
+}
+
+// RelatedStandardIn applies the In predicate on the "related_standard" field.
+func RelatedStandardIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldRelatedStandard, vs...))
+}
+
+// RelatedStandardNotIn applies the NotIn predicate on the "related_standard" field.
+func RelatedStandardNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldRelatedStandard, vs...))
+}
+
+// RelatedStandardGT applies the GT predicate on the "related_standard" field.
+func RelatedStandardGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldRelatedStandard, v))
+}
+
+// RelatedStandardGTE applies the GTE predicate on the "related_standard" field.
+func RelatedStandardGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldRelatedStandard, v))
+}
+
+// RelatedStandardLT applies the LT predicate on the "related_standard" field.
+func RelatedStandardLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldRelatedStandard, v))
+}
+
+// RelatedStandardLTE applies the LTE predicate on the "related_standard" field.
+func RelatedStandardLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldRelatedStandard, v))
+}
+
+// RelatedStandardContains applies the Contains predicate on the "related_standard" field.
+func RelatedStandardContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldRelatedStandard, v))
+}
+
+// RelatedStandardHasPrefix applies the HasPrefix predicate on the "related_standard" field.
+func RelatedStandardHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldRelatedStandard, v))
+}
+
+// RelatedStandardHasSuffix applies the HasSuffix predicate on the "related_standard" field.
+func RelatedStandardHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldRelatedStandard, v))
+}
+
+// RelatedStandardIsNil applies the IsNil predicate on the "related_standard" field.
+func RelatedStandardIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldRelatedStandard))
+}
+
+// RelatedStandardNotNil applies the NotNil predicate on the "related_standard" field.
+func RelatedStandardNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldRelatedStandard))
+}
+
+// RelatedStandardEqualFold applies the EqualFold predicate on the "related_standard" field.
+func RelatedStandardEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldRelatedStandard, v))
+}
+
+// RelatedStandardContainsFold applies the ContainsFold predicate on the "related_standard" field.
+func RelatedStandardContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldRelatedStandard, v))
+}
+
+// TestRecordNoEQ applies the EQ predicate on the "test_record_no" field.
+func TestRecordNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldTestRecordNo, v))
+}
+
+// TestRecordNoNEQ applies the NEQ predicate on the "test_record_no" field.
+func TestRecordNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldTestRecordNo, v))
+}
+
+// TestRecordNoIn applies the In predicate on the "test_record_no" field.
+func TestRecordNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldTestRecordNo, vs...))
+}
+
+// TestRecordNoNotIn applies the NotIn predicate on the "test_record_no" field.
+func TestRecordNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldTestRecordNo, vs...))
+}
+
+// TestRecordNoGT applies the GT predicate on the "test_record_no" field.
+func TestRecordNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldTestRecordNo, v))
+}
+
+// TestRecordNoGTE applies the GTE predicate on the "test_record_no" field.
+func TestRecordNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldTestRecordNo, v))
+}
+
+// TestRecordNoLT applies the LT predicate on the "test_record_no" field.
+func TestRecordNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldTestRecordNo, v))
+}
+
+// TestRecordNoLTE applies the LTE predicate on the "test_record_no" field.
+func TestRecordNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldTestRecordNo, v))
+}
+
+// TestRecordNoContains applies the Contains predicate on the "test_record_no" field.
+func TestRecordNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldTestRecordNo, v))
+}
+
+// TestRecordNoHasPrefix applies the HasPrefix predicate on the "test_record_no" field.
+func TestRecordNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldTestRecordNo, v))
+}
+
+// TestRecordNoHasSuffix applies the HasSuffix predicate on the "test_record_no" field.
+func TestRecordNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldTestRecordNo, v))
+}
+
+// TestRecordNoIsNil applies the IsNil predicate on the "test_record_no" field.
+func TestRecordNoIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldTestRecordNo))
+}
+
+// TestRecordNoNotNil applies the NotNil predicate on the "test_record_no" field.
+func TestRecordNoNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldTestRecordNo))
+}
+
+// TestRecordNoEqualFold applies the EqualFold predicate on the "test_record_no" field.
+func TestRecordNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldTestRecordNo, v))
+}
+
+// TestRecordNoContainsFold applies the ContainsFold predicate on the "test_record_no" field.
+func TestRecordNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldTestRecordNo, v))
+}
+
+// RecordedByEQ applies the EQ predicate on the "recorded_by" field.
+func RecordedByEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldRecordedBy, v))
+}
+
+// RecordedByNEQ applies the NEQ predicate on the "recorded_by" field.
+func RecordedByNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldRecordedBy, v))
+}
+
+// RecordedByIn applies the In predicate on the "recorded_by" field.
+func RecordedByIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldRecordedBy, vs...))
+}
+
+// RecordedByNotIn applies the NotIn predicate on the "recorded_by" field.
+func RecordedByNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldRecordedBy, vs...))
+}
+
+// RecordedByGT applies the GT predicate on the "recorded_by" field.
+func RecordedByGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldRecordedBy, v))
+}
+
+// RecordedByGTE applies the GTE predicate on the "recorded_by" field.
+func RecordedByGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldRecordedBy, v))
+}
+
+// RecordedByLT applies the LT predicate on the "recorded_by" field.
+func RecordedByLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldRecordedBy, v))
+}
+
+// RecordedByLTE applies the LTE predicate on the "recorded_by" field.
+func RecordedByLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldRecordedBy, v))
+}
+
+// RecordedByContains applies the Contains predicate on the "recorded_by" field.
+func RecordedByContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldRecordedBy, v))
+}
+
+// RecordedByHasPrefix applies the HasPrefix predicate on the "recorded_by" field.
+func RecordedByHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldRecordedBy, v))
+}
+
+// RecordedByHasSuffix applies the HasSuffix predicate on the "recorded_by" field.
+func RecordedByHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldRecordedBy, v))
+}
+
+// RecordedByIsNil applies the IsNil predicate on the "recorded_by" field.
+func RecordedByIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldRecordedBy))
+}
+
+// RecordedByNotNil applies the NotNil predicate on the "recorded_by" field.
+func RecordedByNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldRecordedBy))
+}
+
+// RecordedByEqualFold applies the EqualFold predicate on the "recorded_by" field.
+func RecordedByEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldRecordedBy, v))
+}
+
+// RecordedByContainsFold applies the ContainsFold predicate on the "recorded_by" field.
+func RecordedByContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldRecordedBy, v))
+}
+
+// RecordedAtEQ applies the EQ predicate on the "recorded_at" field.
+func RecordedAtEQ(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldRecordedAt, v))
+}
+
+// RecordedAtNEQ applies the NEQ predicate on the "recorded_at" field.
+func RecordedAtNEQ(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldRecordedAt, v))
+}
+
+// RecordedAtIn applies the In predicate on the "recorded_at" field.
+func RecordedAtIn(vs ...int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldRecordedAt, vs...))
+}
+
+// RecordedAtNotIn applies the NotIn predicate on the "recorded_at" field.
+func RecordedAtNotIn(vs ...int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldRecordedAt, vs...))
+}
+
+// RecordedAtGT applies the GT predicate on the "recorded_at" field.
+func RecordedAtGT(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldRecordedAt, v))
+}
+
+// RecordedAtGTE applies the GTE predicate on the "recorded_at" field.
+func RecordedAtGTE(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldRecordedAt, v))
+}
+
+// RecordedAtLT applies the LT predicate on the "recorded_at" field.
+func RecordedAtLT(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldRecordedAt, v))
+}
+
+// RecordedAtLTE applies the LTE predicate on the "recorded_at" field.
+func RecordedAtLTE(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldRecordedAt, v))
+}
+
+// RecordedAtIsNil applies the IsNil predicate on the "recorded_at" field.
+func RecordedAtIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldRecordedAt))
+}
+
+// RecordedAtNotNil applies the NotNil predicate on the "recorded_at" field.
+func RecordedAtNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldRecordedAt))
+}
+
+// OutboundReasonEQ applies the EQ predicate on the "outbound_reason" field.
+func OutboundReasonEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldOutboundReason, v))
+}
+
+// OutboundReasonNEQ applies the NEQ predicate on the "outbound_reason" field.
+func OutboundReasonNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldOutboundReason, v))
+}
+
+// OutboundReasonIn applies the In predicate on the "outbound_reason" field.
+func OutboundReasonIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldOutboundReason, vs...))
+}
+
+// OutboundReasonNotIn applies the NotIn predicate on the "outbound_reason" field.
+func OutboundReasonNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldOutboundReason, vs...))
+}
+
+// OutboundReasonGT applies the GT predicate on the "outbound_reason" field.
+func OutboundReasonGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldOutboundReason, v))
+}
+
+// OutboundReasonGTE applies the GTE predicate on the "outbound_reason" field.
+func OutboundReasonGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldOutboundReason, v))
+}
+
+// OutboundReasonLT applies the LT predicate on the "outbound_reason" field.
+func OutboundReasonLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldOutboundReason, v))
+}
+
+// OutboundReasonLTE applies the LTE predicate on the "outbound_reason" field.
+func OutboundReasonLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldOutboundReason, v))
+}
+
+// OutboundReasonContains applies the Contains predicate on the "outbound_reason" field.
+func OutboundReasonContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldOutboundReason, v))
+}
+
+// OutboundReasonHasPrefix applies the HasPrefix predicate on the "outbound_reason" field.
+func OutboundReasonHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldOutboundReason, v))
+}
+
+// OutboundReasonHasSuffix applies the HasSuffix predicate on the "outbound_reason" field.
+func OutboundReasonHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldOutboundReason, v))
+}
+
+// OutboundReasonIsNil applies the IsNil predicate on the "outbound_reason" field.
+func OutboundReasonIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldOutboundReason))
+}
+
+// OutboundReasonNotNil applies the NotNil predicate on the "outbound_reason" field.
+func OutboundReasonNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldOutboundReason))
+}
+
+// OutboundReasonEqualFold applies the EqualFold predicate on the "outbound_reason" field.
+func OutboundReasonEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldOutboundReason, v))
+}
+
+// OutboundReasonContainsFold applies the ContainsFold predicate on the "outbound_reason" field.
+func OutboundReasonContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldOutboundReason, v))
+}
+
+// StocktakeNoEQ applies the EQ predicate on the "stocktake_no" field.
+func StocktakeNoEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldStocktakeNo, v))
+}
+
+// StocktakeNoNEQ applies the NEQ predicate on the "stocktake_no" field.
+func StocktakeNoNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldStocktakeNo, v))
+}
+
+// StocktakeNoIn applies the In predicate on the "stocktake_no" field.
+func StocktakeNoIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldStocktakeNo, vs...))
+}
+
+// StocktakeNoNotIn applies the NotIn predicate on the "stocktake_no" field.
+func StocktakeNoNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldStocktakeNo, vs...))
+}
+
+// StocktakeNoGT applies the GT predicate on the "stocktake_no" field.
+func StocktakeNoGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldStocktakeNo, v))
+}
+
+// StocktakeNoGTE applies the GTE predicate on the "stocktake_no" field.
+func StocktakeNoGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldStocktakeNo, v))
+}
+
+// StocktakeNoLT applies the LT predicate on the "stocktake_no" field.
+func StocktakeNoLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldStocktakeNo, v))
+}
+
+// StocktakeNoLTE applies the LTE predicate on the "stocktake_no" field.
+func StocktakeNoLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldStocktakeNo, v))
+}
+
+// StocktakeNoContains applies the Contains predicate on the "stocktake_no" field.
+func StocktakeNoContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldStocktakeNo, v))
+}
+
+// StocktakeNoHasPrefix applies the HasPrefix predicate on the "stocktake_no" field.
+func StocktakeNoHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldStocktakeNo, v))
+}
+
+// StocktakeNoHasSuffix applies the HasSuffix predicate on the "stocktake_no" field.
+func StocktakeNoHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldStocktakeNo, v))
+}
+
+// StocktakeNoEqualFold applies the EqualFold predicate on the "stocktake_no" field.
+func StocktakeNoEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldStocktakeNo, v))
+}
+
+// StocktakeNoContainsFold applies the ContainsFold predicate on the "stocktake_no" field.
+func StocktakeNoContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldStocktakeNo, v))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.Inventory {
+	return predicate.Inventory(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.Inventory {
+	return predicate.Inventory(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Inventory) predicate.Inventory {
+	return predicate.Inventory(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Inventory) predicate.Inventory {
+	return predicate.Inventory(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Inventory) predicate.Inventory {
+	return predicate.Inventory(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/inventorylock/inventorylock.go b/bj_power_wms/inventorylock/inventorylock.go
new file mode 100644
index 0000000..868d50d
--- /dev/null
+++ b/bj_power_wms/inventorylock/inventorylock.go
@@ -0,0 +1,130 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inventorylock
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the inventorylock type in the database.
+	Label = "inventory_lock"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldTargetType holds the string denoting the target_type field in the database.
+	FieldTargetType = "target_type"
+	// FieldTargetID holds the string denoting the target_id field in the database.
+	FieldTargetID = "target_id"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldLockedQty holds the string denoting the locked_qty field in the database.
+	FieldLockedQty = "locked_qty"
+	// FieldOrderNo holds the string denoting the order_no field in the database.
+	FieldOrderNo = "order_no"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldExpiredAt holds the string denoting the expired_at field in the database.
+	FieldExpiredAt = "expired_at"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the inventorylock in the database.
+	Table = "inventory_locks"
+)
+
+// Columns holds all SQL columns for inventorylock fields.
+var Columns = []string{
+	FieldID,
+	FieldTargetType,
+	FieldTargetID,
+	FieldMaterialCode,
+	FieldLockedQty,
+	FieldOrderNo,
+	FieldStatus,
+	FieldExpiredAt,
+	FieldRemark,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultLockedQty holds the default value on creation for the "locked_qty" field.
+	DefaultLockedQty int
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the InventoryLock queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByTargetType orders the results by the target_type field.
+func ByTargetType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetType, opts...).ToFunc()
+}
+
+// ByTargetID orders the results by the target_id field.
+func ByTargetID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetID, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByLockedQty orders the results by the locked_qty field.
+func ByLockedQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLockedQty, opts...).ToFunc()
+}
+
+// ByOrderNo orders the results by the order_no field.
+func ByOrderNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOrderNo, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByExpiredAt orders the results by the expired_at field.
+func ByExpiredAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldExpiredAt, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/inventorylock/where.go b/bj_power_wms/inventorylock/where.go
new file mode 100644
index 0000000..d405ec8
--- /dev/null
+++ b/bj_power_wms/inventorylock/where.go
@@ -0,0 +1,689 @@
+// Code generated by ent, DO NOT EDIT.
+
+package inventorylock
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldID, id))
+}
+
+// TargetType applies equality check predicate on the "target_type" field. It's identical to TargetTypeEQ.
+func TargetType(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldTargetType, v))
+}
+
+// TargetID applies equality check predicate on the "target_id" field. It's identical to TargetIDEQ.
+func TargetID(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldTargetID, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// LockedQty applies equality check predicate on the "locked_qty" field. It's identical to LockedQtyEQ.
+func LockedQty(v int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldLockedQty, v))
+}
+
+// OrderNo applies equality check predicate on the "order_no" field. It's identical to OrderNoEQ.
+func OrderNo(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldStatus, v))
+}
+
+// ExpiredAt applies equality check predicate on the "expired_at" field. It's identical to ExpiredAtEQ.
+func ExpiredAt(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldExpiredAt, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldRemark, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// TargetTypeEQ applies the EQ predicate on the "target_type" field.
+func TargetTypeEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldTargetType, v))
+}
+
+// TargetTypeNEQ applies the NEQ predicate on the "target_type" field.
+func TargetTypeNEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldTargetType, v))
+}
+
+// TargetTypeIn applies the In predicate on the "target_type" field.
+func TargetTypeIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldTargetType, vs...))
+}
+
+// TargetTypeNotIn applies the NotIn predicate on the "target_type" field.
+func TargetTypeNotIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldTargetType, vs...))
+}
+
+// TargetTypeGT applies the GT predicate on the "target_type" field.
+func TargetTypeGT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldTargetType, v))
+}
+
+// TargetTypeGTE applies the GTE predicate on the "target_type" field.
+func TargetTypeGTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldTargetType, v))
+}
+
+// TargetTypeLT applies the LT predicate on the "target_type" field.
+func TargetTypeLT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldTargetType, v))
+}
+
+// TargetTypeLTE applies the LTE predicate on the "target_type" field.
+func TargetTypeLTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldTargetType, v))
+}
+
+// TargetTypeContains applies the Contains predicate on the "target_type" field.
+func TargetTypeContains(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContains(FieldTargetType, v))
+}
+
+// TargetTypeHasPrefix applies the HasPrefix predicate on the "target_type" field.
+func TargetTypeHasPrefix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasPrefix(FieldTargetType, v))
+}
+
+// TargetTypeHasSuffix applies the HasSuffix predicate on the "target_type" field.
+func TargetTypeHasSuffix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasSuffix(FieldTargetType, v))
+}
+
+// TargetTypeEqualFold applies the EqualFold predicate on the "target_type" field.
+func TargetTypeEqualFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEqualFold(FieldTargetType, v))
+}
+
+// TargetTypeContainsFold applies the ContainsFold predicate on the "target_type" field.
+func TargetTypeContainsFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContainsFold(FieldTargetType, v))
+}
+
+// TargetIDEQ applies the EQ predicate on the "target_id" field.
+func TargetIDEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldTargetID, v))
+}
+
+// TargetIDNEQ applies the NEQ predicate on the "target_id" field.
+func TargetIDNEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldTargetID, v))
+}
+
+// TargetIDIn applies the In predicate on the "target_id" field.
+func TargetIDIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldTargetID, vs...))
+}
+
+// TargetIDNotIn applies the NotIn predicate on the "target_id" field.
+func TargetIDNotIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldTargetID, vs...))
+}
+
+// TargetIDGT applies the GT predicate on the "target_id" field.
+func TargetIDGT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldTargetID, v))
+}
+
+// TargetIDGTE applies the GTE predicate on the "target_id" field.
+func TargetIDGTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldTargetID, v))
+}
+
+// TargetIDLT applies the LT predicate on the "target_id" field.
+func TargetIDLT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldTargetID, v))
+}
+
+// TargetIDLTE applies the LTE predicate on the "target_id" field.
+func TargetIDLTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldTargetID, v))
+}
+
+// TargetIDContains applies the Contains predicate on the "target_id" field.
+func TargetIDContains(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContains(FieldTargetID, v))
+}
+
+// TargetIDHasPrefix applies the HasPrefix predicate on the "target_id" field.
+func TargetIDHasPrefix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasPrefix(FieldTargetID, v))
+}
+
+// TargetIDHasSuffix applies the HasSuffix predicate on the "target_id" field.
+func TargetIDHasSuffix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasSuffix(FieldTargetID, v))
+}
+
+// TargetIDEqualFold applies the EqualFold predicate on the "target_id" field.
+func TargetIDEqualFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEqualFold(FieldTargetID, v))
+}
+
+// TargetIDContainsFold applies the ContainsFold predicate on the "target_id" field.
+func TargetIDContainsFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContainsFold(FieldTargetID, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// LockedQtyEQ applies the EQ predicate on the "locked_qty" field.
+func LockedQtyEQ(v int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldLockedQty, v))
+}
+
+// LockedQtyNEQ applies the NEQ predicate on the "locked_qty" field.
+func LockedQtyNEQ(v int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldLockedQty, v))
+}
+
+// LockedQtyIn applies the In predicate on the "locked_qty" field.
+func LockedQtyIn(vs ...int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldLockedQty, vs...))
+}
+
+// LockedQtyNotIn applies the NotIn predicate on the "locked_qty" field.
+func LockedQtyNotIn(vs ...int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldLockedQty, vs...))
+}
+
+// LockedQtyGT applies the GT predicate on the "locked_qty" field.
+func LockedQtyGT(v int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldLockedQty, v))
+}
+
+// LockedQtyGTE applies the GTE predicate on the "locked_qty" field.
+func LockedQtyGTE(v int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldLockedQty, v))
+}
+
+// LockedQtyLT applies the LT predicate on the "locked_qty" field.
+func LockedQtyLT(v int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldLockedQty, v))
+}
+
+// LockedQtyLTE applies the LTE predicate on the "locked_qty" field.
+func LockedQtyLTE(v int) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldLockedQty, v))
+}
+
+// OrderNoEQ applies the EQ predicate on the "order_no" field.
+func OrderNoEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// OrderNoNEQ applies the NEQ predicate on the "order_no" field.
+func OrderNoNEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldOrderNo, v))
+}
+
+// OrderNoIn applies the In predicate on the "order_no" field.
+func OrderNoIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldOrderNo, vs...))
+}
+
+// OrderNoNotIn applies the NotIn predicate on the "order_no" field.
+func OrderNoNotIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldOrderNo, vs...))
+}
+
+// OrderNoGT applies the GT predicate on the "order_no" field.
+func OrderNoGT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldOrderNo, v))
+}
+
+// OrderNoGTE applies the GTE predicate on the "order_no" field.
+func OrderNoGTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldOrderNo, v))
+}
+
+// OrderNoLT applies the LT predicate on the "order_no" field.
+func OrderNoLT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldOrderNo, v))
+}
+
+// OrderNoLTE applies the LTE predicate on the "order_no" field.
+func OrderNoLTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldOrderNo, v))
+}
+
+// OrderNoContains applies the Contains predicate on the "order_no" field.
+func OrderNoContains(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContains(FieldOrderNo, v))
+}
+
+// OrderNoHasPrefix applies the HasPrefix predicate on the "order_no" field.
+func OrderNoHasPrefix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasPrefix(FieldOrderNo, v))
+}
+
+// OrderNoHasSuffix applies the HasSuffix predicate on the "order_no" field.
+func OrderNoHasSuffix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasSuffix(FieldOrderNo, v))
+}
+
+// OrderNoEqualFold applies the EqualFold predicate on the "order_no" field.
+func OrderNoEqualFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEqualFold(FieldOrderNo, v))
+}
+
+// OrderNoContainsFold applies the ContainsFold predicate on the "order_no" field.
+func OrderNoContainsFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContainsFold(FieldOrderNo, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// ExpiredAtEQ applies the EQ predicate on the "expired_at" field.
+func ExpiredAtEQ(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldExpiredAt, v))
+}
+
+// ExpiredAtNEQ applies the NEQ predicate on the "expired_at" field.
+func ExpiredAtNEQ(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldExpiredAt, v))
+}
+
+// ExpiredAtIn applies the In predicate on the "expired_at" field.
+func ExpiredAtIn(vs ...int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldExpiredAt, vs...))
+}
+
+// ExpiredAtNotIn applies the NotIn predicate on the "expired_at" field.
+func ExpiredAtNotIn(vs ...int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldExpiredAt, vs...))
+}
+
+// ExpiredAtGT applies the GT predicate on the "expired_at" field.
+func ExpiredAtGT(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldExpiredAt, v))
+}
+
+// ExpiredAtGTE applies the GTE predicate on the "expired_at" field.
+func ExpiredAtGTE(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldExpiredAt, v))
+}
+
+// ExpiredAtLT applies the LT predicate on the "expired_at" field.
+func ExpiredAtLT(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldExpiredAt, v))
+}
+
+// ExpiredAtLTE applies the LTE predicate on the "expired_at" field.
+func ExpiredAtLTE(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldExpiredAt, v))
+}
+
+// ExpiredAtIsNil applies the IsNil predicate on the "expired_at" field.
+func ExpiredAtIsNil() predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIsNull(FieldExpiredAt))
+}
+
+// ExpiredAtNotNil applies the NotNil predicate on the "expired_at" field.
+func ExpiredAtNotNil() predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotNull(FieldExpiredAt))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.InventoryLock) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.InventoryLock) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.InventoryLock) predicate.InventoryLock {
+	return predicate.InventoryLock(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/material/material.go b/bj_power_wms/material/material.go
new file mode 100644
index 0000000..f990ce7
--- /dev/null
+++ b/bj_power_wms/material/material.go
@@ -0,0 +1,170 @@
+// Code generated by ent, DO NOT EDIT.
+
+package material
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the material type in the database.
+	Label = "material"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCode holds the string denoting the code field in the database.
+	FieldCode = "code"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldSpec holds the string denoting the spec field in the database.
+	FieldSpec = "spec"
+	// FieldUnit holds the string denoting the unit field in the database.
+	FieldUnit = "unit"
+	// FieldDescription holds the string denoting the description field in the database.
+	FieldDescription = "description"
+	// FieldItemType holds the string denoting the item_type field in the database.
+	FieldItemType = "item_type"
+	// FieldManageMode holds the string denoting the manage_mode field in the database.
+	FieldManageMode = "manage_mode"
+	// FieldIsBatchManaged holds the string denoting the is_batch_managed field in the database.
+	FieldIsBatchManaged = "is_batch_managed"
+	// FieldIsSerialManaged holds the string denoting the is_serial_managed field in the database.
+	FieldIsSerialManaged = "is_serial_managed"
+	// FieldTemplateCode holds the string denoting the template_code field in the database.
+	FieldTemplateCode = "template_code"
+	// FieldSafetyStock holds the string denoting the safety_stock field in the database.
+	FieldSafetyStock = "safety_stock"
+	// FieldIsActive holds the string denoting the is_active field in the database.
+	FieldIsActive = "is_active"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the material in the database.
+	Table = "materials"
+)
+
+// Columns holds all SQL columns for material fields.
+var Columns = []string{
+	FieldID,
+	FieldCode,
+	FieldName,
+	FieldSpec,
+	FieldUnit,
+	FieldDescription,
+	FieldItemType,
+	FieldManageMode,
+	FieldIsBatchManaged,
+	FieldIsSerialManaged,
+	FieldTemplateCode,
+	FieldSafetyStock,
+	FieldIsActive,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultItemType holds the default value on creation for the "item_type" field.
+	DefaultItemType int
+	// DefaultManageMode holds the default value on creation for the "manage_mode" field.
+	DefaultManageMode int
+	// DefaultIsBatchManaged holds the default value on creation for the "is_batch_managed" field.
+	DefaultIsBatchManaged bool
+	// DefaultIsSerialManaged holds the default value on creation for the "is_serial_managed" field.
+	DefaultIsSerialManaged bool
+	// DefaultSafetyStock holds the default value on creation for the "safety_stock" field.
+	DefaultSafetyStock int
+	// DefaultIsActive holds the default value on creation for the "is_active" field.
+	DefaultIsActive bool
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the Material queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCode orders the results by the code field.
+func ByCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCode, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// BySpec orders the results by the spec field.
+func BySpec(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSpec, opts...).ToFunc()
+}
+
+// ByUnit orders the results by the unit field.
+func ByUnit(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUnit, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByItemType orders the results by the item_type field.
+func ByItemType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldItemType, opts...).ToFunc()
+}
+
+// ByManageMode orders the results by the manage_mode field.
+func ByManageMode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldManageMode, opts...).ToFunc()
+}
+
+// ByIsBatchManaged orders the results by the is_batch_managed field.
+func ByIsBatchManaged(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIsBatchManaged, opts...).ToFunc()
+}
+
+// ByIsSerialManaged orders the results by the is_serial_managed field.
+func ByIsSerialManaged(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIsSerialManaged, opts...).ToFunc()
+}
+
+// ByTemplateCode orders the results by the template_code field.
+func ByTemplateCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTemplateCode, opts...).ToFunc()
+}
+
+// BySafetyStock orders the results by the safety_stock field.
+func BySafetyStock(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSafetyStock, opts...).ToFunc()
+}
+
+// ByIsActive orders the results by the is_active field.
+func ByIsActive(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIsActive, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/material/where.go b/bj_power_wms/material/where.go
new file mode 100644
index 0000000..c184d70
--- /dev/null
+++ b/bj_power_wms/material/where.go
@@ -0,0 +1,799 @@
+// Code generated by ent, DO NOT EDIT.
+
+package material
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldID, id))
+}
+
+// Code applies equality check predicate on the "code" field. It's identical to CodeEQ.
+func Code(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldCode, v))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldName, v))
+}
+
+// Spec applies equality check predicate on the "spec" field. It's identical to SpecEQ.
+func Spec(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldSpec, v))
+}
+
+// Unit applies equality check predicate on the "unit" field. It's identical to UnitEQ.
+func Unit(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldUnit, v))
+}
+
+// Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ.
+func Description(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldDescription, v))
+}
+
+// ItemType applies equality check predicate on the "item_type" field. It's identical to ItemTypeEQ.
+func ItemType(v int) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldItemType, v))
+}
+
+// ManageMode applies equality check predicate on the "manage_mode" field. It's identical to ManageModeEQ.
+func ManageMode(v int) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldManageMode, v))
+}
+
+// IsBatchManaged applies equality check predicate on the "is_batch_managed" field. It's identical to IsBatchManagedEQ.
+func IsBatchManaged(v bool) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldIsBatchManaged, v))
+}
+
+// IsSerialManaged applies equality check predicate on the "is_serial_managed" field. It's identical to IsSerialManagedEQ.
+func IsSerialManaged(v bool) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldIsSerialManaged, v))
+}
+
+// TemplateCode applies equality check predicate on the "template_code" field. It's identical to TemplateCodeEQ.
+func TemplateCode(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldTemplateCode, v))
+}
+
+// SafetyStock applies equality check predicate on the "safety_stock" field. It's identical to SafetyStockEQ.
+func SafetyStock(v int) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldSafetyStock, v))
+}
+
+// IsActive applies equality check predicate on the "is_active" field. It's identical to IsActiveEQ.
+func IsActive(v bool) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldIsActive, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// CodeEQ applies the EQ predicate on the "code" field.
+func CodeEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldCode, v))
+}
+
+// CodeNEQ applies the NEQ predicate on the "code" field.
+func CodeNEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldCode, v))
+}
+
+// CodeIn applies the In predicate on the "code" field.
+func CodeIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldCode, vs...))
+}
+
+// CodeNotIn applies the NotIn predicate on the "code" field.
+func CodeNotIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldCode, vs...))
+}
+
+// CodeGT applies the GT predicate on the "code" field.
+func CodeGT(v string) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldCode, v))
+}
+
+// CodeGTE applies the GTE predicate on the "code" field.
+func CodeGTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldCode, v))
+}
+
+// CodeLT applies the LT predicate on the "code" field.
+func CodeLT(v string) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldCode, v))
+}
+
+// CodeLTE applies the LTE predicate on the "code" field.
+func CodeLTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldCode, v))
+}
+
+// CodeContains applies the Contains predicate on the "code" field.
+func CodeContains(v string) predicate.Material {
+	return predicate.Material(sql.FieldContains(FieldCode, v))
+}
+
+// CodeHasPrefix applies the HasPrefix predicate on the "code" field.
+func CodeHasPrefix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasPrefix(FieldCode, v))
+}
+
+// CodeHasSuffix applies the HasSuffix predicate on the "code" field.
+func CodeHasSuffix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasSuffix(FieldCode, v))
+}
+
+// CodeEqualFold applies the EqualFold predicate on the "code" field.
+func CodeEqualFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldEqualFold(FieldCode, v))
+}
+
+// CodeContainsFold applies the ContainsFold predicate on the "code" field.
+func CodeContainsFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldContainsFold(FieldCode, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.Material {
+	return predicate.Material(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldContainsFold(FieldName, v))
+}
+
+// SpecEQ applies the EQ predicate on the "spec" field.
+func SpecEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldSpec, v))
+}
+
+// SpecNEQ applies the NEQ predicate on the "spec" field.
+func SpecNEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldSpec, v))
+}
+
+// SpecIn applies the In predicate on the "spec" field.
+func SpecIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldSpec, vs...))
+}
+
+// SpecNotIn applies the NotIn predicate on the "spec" field.
+func SpecNotIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldSpec, vs...))
+}
+
+// SpecGT applies the GT predicate on the "spec" field.
+func SpecGT(v string) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldSpec, v))
+}
+
+// SpecGTE applies the GTE predicate on the "spec" field.
+func SpecGTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldSpec, v))
+}
+
+// SpecLT applies the LT predicate on the "spec" field.
+func SpecLT(v string) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldSpec, v))
+}
+
+// SpecLTE applies the LTE predicate on the "spec" field.
+func SpecLTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldSpec, v))
+}
+
+// SpecContains applies the Contains predicate on the "spec" field.
+func SpecContains(v string) predicate.Material {
+	return predicate.Material(sql.FieldContains(FieldSpec, v))
+}
+
+// SpecHasPrefix applies the HasPrefix predicate on the "spec" field.
+func SpecHasPrefix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasPrefix(FieldSpec, v))
+}
+
+// SpecHasSuffix applies the HasSuffix predicate on the "spec" field.
+func SpecHasSuffix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasSuffix(FieldSpec, v))
+}
+
+// SpecIsNil applies the IsNil predicate on the "spec" field.
+func SpecIsNil() predicate.Material {
+	return predicate.Material(sql.FieldIsNull(FieldSpec))
+}
+
+// SpecNotNil applies the NotNil predicate on the "spec" field.
+func SpecNotNil() predicate.Material {
+	return predicate.Material(sql.FieldNotNull(FieldSpec))
+}
+
+// SpecEqualFold applies the EqualFold predicate on the "spec" field.
+func SpecEqualFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldEqualFold(FieldSpec, v))
+}
+
+// SpecContainsFold applies the ContainsFold predicate on the "spec" field.
+func SpecContainsFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldContainsFold(FieldSpec, v))
+}
+
+// UnitEQ applies the EQ predicate on the "unit" field.
+func UnitEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldUnit, v))
+}
+
+// UnitNEQ applies the NEQ predicate on the "unit" field.
+func UnitNEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldUnit, v))
+}
+
+// UnitIn applies the In predicate on the "unit" field.
+func UnitIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldUnit, vs...))
+}
+
+// UnitNotIn applies the NotIn predicate on the "unit" field.
+func UnitNotIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldUnit, vs...))
+}
+
+// UnitGT applies the GT predicate on the "unit" field.
+func UnitGT(v string) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldUnit, v))
+}
+
+// UnitGTE applies the GTE predicate on the "unit" field.
+func UnitGTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldUnit, v))
+}
+
+// UnitLT applies the LT predicate on the "unit" field.
+func UnitLT(v string) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldUnit, v))
+}
+
+// UnitLTE applies the LTE predicate on the "unit" field.
+func UnitLTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldUnit, v))
+}
+
+// UnitContains applies the Contains predicate on the "unit" field.
+func UnitContains(v string) predicate.Material {
+	return predicate.Material(sql.FieldContains(FieldUnit, v))
+}
+
+// UnitHasPrefix applies the HasPrefix predicate on the "unit" field.
+func UnitHasPrefix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasPrefix(FieldUnit, v))
+}
+
+// UnitHasSuffix applies the HasSuffix predicate on the "unit" field.
+func UnitHasSuffix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasSuffix(FieldUnit, v))
+}
+
+// UnitIsNil applies the IsNil predicate on the "unit" field.
+func UnitIsNil() predicate.Material {
+	return predicate.Material(sql.FieldIsNull(FieldUnit))
+}
+
+// UnitNotNil applies the NotNil predicate on the "unit" field.
+func UnitNotNil() predicate.Material {
+	return predicate.Material(sql.FieldNotNull(FieldUnit))
+}
+
+// UnitEqualFold applies the EqualFold predicate on the "unit" field.
+func UnitEqualFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldEqualFold(FieldUnit, v))
+}
+
+// UnitContainsFold applies the ContainsFold predicate on the "unit" field.
+func UnitContainsFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldContainsFold(FieldUnit, v))
+}
+
+// DescriptionEQ applies the EQ predicate on the "description" field.
+func DescriptionEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldDescription, v))
+}
+
+// DescriptionNEQ applies the NEQ predicate on the "description" field.
+func DescriptionNEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldDescription, v))
+}
+
+// DescriptionIn applies the In predicate on the "description" field.
+func DescriptionIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldDescription, vs...))
+}
+
+// DescriptionNotIn applies the NotIn predicate on the "description" field.
+func DescriptionNotIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldDescription, vs...))
+}
+
+// DescriptionGT applies the GT predicate on the "description" field.
+func DescriptionGT(v string) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldDescription, v))
+}
+
+// DescriptionGTE applies the GTE predicate on the "description" field.
+func DescriptionGTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldDescription, v))
+}
+
+// DescriptionLT applies the LT predicate on the "description" field.
+func DescriptionLT(v string) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldDescription, v))
+}
+
+// DescriptionLTE applies the LTE predicate on the "description" field.
+func DescriptionLTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldDescription, v))
+}
+
+// DescriptionContains applies the Contains predicate on the "description" field.
+func DescriptionContains(v string) predicate.Material {
+	return predicate.Material(sql.FieldContains(FieldDescription, v))
+}
+
+// DescriptionHasPrefix applies the HasPrefix predicate on the "description" field.
+func DescriptionHasPrefix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasPrefix(FieldDescription, v))
+}
+
+// DescriptionHasSuffix applies the HasSuffix predicate on the "description" field.
+func DescriptionHasSuffix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasSuffix(FieldDescription, v))
+}
+
+// DescriptionIsNil applies the IsNil predicate on the "description" field.
+func DescriptionIsNil() predicate.Material {
+	return predicate.Material(sql.FieldIsNull(FieldDescription))
+}
+
+// DescriptionNotNil applies the NotNil predicate on the "description" field.
+func DescriptionNotNil() predicate.Material {
+	return predicate.Material(sql.FieldNotNull(FieldDescription))
+}
+
+// DescriptionEqualFold applies the EqualFold predicate on the "description" field.
+func DescriptionEqualFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldEqualFold(FieldDescription, v))
+}
+
+// DescriptionContainsFold applies the ContainsFold predicate on the "description" field.
+func DescriptionContainsFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldContainsFold(FieldDescription, v))
+}
+
+// ItemTypeEQ applies the EQ predicate on the "item_type" field.
+func ItemTypeEQ(v int) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldItemType, v))
+}
+
+// ItemTypeNEQ applies the NEQ predicate on the "item_type" field.
+func ItemTypeNEQ(v int) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldItemType, v))
+}
+
+// ItemTypeIn applies the In predicate on the "item_type" field.
+func ItemTypeIn(vs ...int) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldItemType, vs...))
+}
+
+// ItemTypeNotIn applies the NotIn predicate on the "item_type" field.
+func ItemTypeNotIn(vs ...int) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldItemType, vs...))
+}
+
+// ItemTypeGT applies the GT predicate on the "item_type" field.
+func ItemTypeGT(v int) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldItemType, v))
+}
+
+// ItemTypeGTE applies the GTE predicate on the "item_type" field.
+func ItemTypeGTE(v int) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldItemType, v))
+}
+
+// ItemTypeLT applies the LT predicate on the "item_type" field.
+func ItemTypeLT(v int) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldItemType, v))
+}
+
+// ItemTypeLTE applies the LTE predicate on the "item_type" field.
+func ItemTypeLTE(v int) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldItemType, v))
+}
+
+// ManageModeEQ applies the EQ predicate on the "manage_mode" field.
+func ManageModeEQ(v int) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldManageMode, v))
+}
+
+// ManageModeNEQ applies the NEQ predicate on the "manage_mode" field.
+func ManageModeNEQ(v int) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldManageMode, v))
+}
+
+// ManageModeIn applies the In predicate on the "manage_mode" field.
+func ManageModeIn(vs ...int) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldManageMode, vs...))
+}
+
+// ManageModeNotIn applies the NotIn predicate on the "manage_mode" field.
+func ManageModeNotIn(vs ...int) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldManageMode, vs...))
+}
+
+// ManageModeGT applies the GT predicate on the "manage_mode" field.
+func ManageModeGT(v int) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldManageMode, v))
+}
+
+// ManageModeGTE applies the GTE predicate on the "manage_mode" field.
+func ManageModeGTE(v int) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldManageMode, v))
+}
+
+// ManageModeLT applies the LT predicate on the "manage_mode" field.
+func ManageModeLT(v int) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldManageMode, v))
+}
+
+// ManageModeLTE applies the LTE predicate on the "manage_mode" field.
+func ManageModeLTE(v int) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldManageMode, v))
+}
+
+// IsBatchManagedEQ applies the EQ predicate on the "is_batch_managed" field.
+func IsBatchManagedEQ(v bool) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldIsBatchManaged, v))
+}
+
+// IsBatchManagedNEQ applies the NEQ predicate on the "is_batch_managed" field.
+func IsBatchManagedNEQ(v bool) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldIsBatchManaged, v))
+}
+
+// IsSerialManagedEQ applies the EQ predicate on the "is_serial_managed" field.
+func IsSerialManagedEQ(v bool) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldIsSerialManaged, v))
+}
+
+// IsSerialManagedNEQ applies the NEQ predicate on the "is_serial_managed" field.
+func IsSerialManagedNEQ(v bool) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldIsSerialManaged, v))
+}
+
+// TemplateCodeEQ applies the EQ predicate on the "template_code" field.
+func TemplateCodeEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldTemplateCode, v))
+}
+
+// TemplateCodeNEQ applies the NEQ predicate on the "template_code" field.
+func TemplateCodeNEQ(v string) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldTemplateCode, v))
+}
+
+// TemplateCodeIn applies the In predicate on the "template_code" field.
+func TemplateCodeIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldTemplateCode, vs...))
+}
+
+// TemplateCodeNotIn applies the NotIn predicate on the "template_code" field.
+func TemplateCodeNotIn(vs ...string) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldTemplateCode, vs...))
+}
+
+// TemplateCodeGT applies the GT predicate on the "template_code" field.
+func TemplateCodeGT(v string) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldTemplateCode, v))
+}
+
+// TemplateCodeGTE applies the GTE predicate on the "template_code" field.
+func TemplateCodeGTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldTemplateCode, v))
+}
+
+// TemplateCodeLT applies the LT predicate on the "template_code" field.
+func TemplateCodeLT(v string) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldTemplateCode, v))
+}
+
+// TemplateCodeLTE applies the LTE predicate on the "template_code" field.
+func TemplateCodeLTE(v string) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldTemplateCode, v))
+}
+
+// TemplateCodeContains applies the Contains predicate on the "template_code" field.
+func TemplateCodeContains(v string) predicate.Material {
+	return predicate.Material(sql.FieldContains(FieldTemplateCode, v))
+}
+
+// TemplateCodeHasPrefix applies the HasPrefix predicate on the "template_code" field.
+func TemplateCodeHasPrefix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasPrefix(FieldTemplateCode, v))
+}
+
+// TemplateCodeHasSuffix applies the HasSuffix predicate on the "template_code" field.
+func TemplateCodeHasSuffix(v string) predicate.Material {
+	return predicate.Material(sql.FieldHasSuffix(FieldTemplateCode, v))
+}
+
+// TemplateCodeIsNil applies the IsNil predicate on the "template_code" field.
+func TemplateCodeIsNil() predicate.Material {
+	return predicate.Material(sql.FieldIsNull(FieldTemplateCode))
+}
+
+// TemplateCodeNotNil applies the NotNil predicate on the "template_code" field.
+func TemplateCodeNotNil() predicate.Material {
+	return predicate.Material(sql.FieldNotNull(FieldTemplateCode))
+}
+
+// TemplateCodeEqualFold applies the EqualFold predicate on the "template_code" field.
+func TemplateCodeEqualFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldEqualFold(FieldTemplateCode, v))
+}
+
+// TemplateCodeContainsFold applies the ContainsFold predicate on the "template_code" field.
+func TemplateCodeContainsFold(v string) predicate.Material {
+	return predicate.Material(sql.FieldContainsFold(FieldTemplateCode, v))
+}
+
+// SafetyStockEQ applies the EQ predicate on the "safety_stock" field.
+func SafetyStockEQ(v int) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldSafetyStock, v))
+}
+
+// SafetyStockNEQ applies the NEQ predicate on the "safety_stock" field.
+func SafetyStockNEQ(v int) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldSafetyStock, v))
+}
+
+// SafetyStockIn applies the In predicate on the "safety_stock" field.
+func SafetyStockIn(vs ...int) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldSafetyStock, vs...))
+}
+
+// SafetyStockNotIn applies the NotIn predicate on the "safety_stock" field.
+func SafetyStockNotIn(vs ...int) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldSafetyStock, vs...))
+}
+
+// SafetyStockGT applies the GT predicate on the "safety_stock" field.
+func SafetyStockGT(v int) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldSafetyStock, v))
+}
+
+// SafetyStockGTE applies the GTE predicate on the "safety_stock" field.
+func SafetyStockGTE(v int) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldSafetyStock, v))
+}
+
+// SafetyStockLT applies the LT predicate on the "safety_stock" field.
+func SafetyStockLT(v int) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldSafetyStock, v))
+}
+
+// SafetyStockLTE applies the LTE predicate on the "safety_stock" field.
+func SafetyStockLTE(v int) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldSafetyStock, v))
+}
+
+// IsActiveEQ applies the EQ predicate on the "is_active" field.
+func IsActiveEQ(v bool) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldIsActive, v))
+}
+
+// IsActiveNEQ applies the NEQ predicate on the "is_active" field.
+func IsActiveNEQ(v bool) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldIsActive, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.Material {
+	return predicate.Material(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.Material {
+	return predicate.Material(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.Material {
+	return predicate.Material(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.Material {
+	return predicate.Material(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.Material {
+	return predicate.Material(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.Material {
+	return predicate.Material(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.Material {
+	return predicate.Material(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.Material {
+	return predicate.Material(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Material) predicate.Material {
+	return predicate.Material(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Material) predicate.Material {
+	return predicate.Material(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Material) predicate.Material {
+	return predicate.Material(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/materialdemand/materialdemand.go b/bj_power_wms/materialdemand/materialdemand.go
new file mode 100644
index 0000000..80036d8
--- /dev/null
+++ b/bj_power_wms/materialdemand/materialdemand.go
@@ -0,0 +1,70 @@
+// Code generated by ent, DO NOT EDIT.
+
+package materialdemand
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the materialdemand type in the database.
+	Label = "material_demand"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldFuture5Qty holds the string denoting the future5_qty field in the database.
+	FieldFuture5Qty = "future5_qty"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the materialdemand in the database.
+	Table = "material_demands"
+)
+
+// Columns holds all SQL columns for materialdemand fields.
+var Columns = []string{
+	FieldID,
+	FieldMaterialCode,
+	FieldFuture5Qty,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultFuture5Qty holds the default value on creation for the "future5_qty" field.
+	DefaultFuture5Qty int
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the MaterialDemand queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByFuture5Qty orders the results by the future5_qty field.
+func ByFuture5Qty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldFuture5Qty, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/materialdemand/where.go b/bj_power_wms/materialdemand/where.go
new file mode 100644
index 0000000..f3a73b1
--- /dev/null
+++ b/bj_power_wms/materialdemand/where.go
@@ -0,0 +1,229 @@
+// Code generated by ent, DO NOT EDIT.
+
+package materialdemand
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldLTE(FieldID, id))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// Future5Qty applies equality check predicate on the "future5_qty" field. It's identical to Future5QtyEQ.
+func Future5Qty(v int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEQ(FieldFuture5Qty, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// Future5QtyEQ applies the EQ predicate on the "future5_qty" field.
+func Future5QtyEQ(v int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEQ(FieldFuture5Qty, v))
+}
+
+// Future5QtyNEQ applies the NEQ predicate on the "future5_qty" field.
+func Future5QtyNEQ(v int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldNEQ(FieldFuture5Qty, v))
+}
+
+// Future5QtyIn applies the In predicate on the "future5_qty" field.
+func Future5QtyIn(vs ...int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldIn(FieldFuture5Qty, vs...))
+}
+
+// Future5QtyNotIn applies the NotIn predicate on the "future5_qty" field.
+func Future5QtyNotIn(vs ...int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldNotIn(FieldFuture5Qty, vs...))
+}
+
+// Future5QtyGT applies the GT predicate on the "future5_qty" field.
+func Future5QtyGT(v int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldGT(FieldFuture5Qty, v))
+}
+
+// Future5QtyGTE applies the GTE predicate on the "future5_qty" field.
+func Future5QtyGTE(v int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldGTE(FieldFuture5Qty, v))
+}
+
+// Future5QtyLT applies the LT predicate on the "future5_qty" field.
+func Future5QtyLT(v int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldLT(FieldFuture5Qty, v))
+}
+
+// Future5QtyLTE applies the LTE predicate on the "future5_qty" field.
+func Future5QtyLTE(v int) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldLTE(FieldFuture5Qty, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.MaterialDemand) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.MaterialDemand) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.MaterialDemand) predicate.MaterialDemand {
+	return predicate.MaterialDemand(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/migrate/migrate.go b/bj_power_wms/migrate/migrate.go
new file mode 100644
index 0000000..1956a6b
--- /dev/null
+++ b/bj_power_wms/migrate/migrate.go
@@ -0,0 +1,64 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+	"context"
+	"fmt"
+	"io"
+
+	"entgo.io/ent/dialect"
+	"entgo.io/ent/dialect/sql/schema"
+)
+
+var (
+	// WithGlobalUniqueID sets the universal ids options to the migration.
+	// If this option is enabled, ent migration will allocate a 1<<32 range
+	// for the ids of each entity (table).
+	// Note that this option cannot be applied on tables that already exist.
+	WithGlobalUniqueID = schema.WithGlobalUniqueID
+	// WithDropColumn sets the drop column option to the migration.
+	// If this option is enabled, ent migration will drop old columns
+	// that were used for both fields and edges. This defaults to false.
+	WithDropColumn = schema.WithDropColumn
+	// WithDropIndex sets the drop index option to the migration.
+	// If this option is enabled, ent migration will drop old indexes
+	// that were defined in the schema. This defaults to false.
+	// Note that unique constraints are defined using `UNIQUE INDEX`,
+	// and therefore, it's recommended to enable this option to get more
+	// flexibility in the schema changes.
+	WithDropIndex = schema.WithDropIndex
+	// WithForeignKeys enables creating foreign-key in schema DDL. This defaults to true.
+	WithForeignKeys = schema.WithForeignKeys
+)
+
+// Schema is the API for creating, migrating and dropping a schema.
+type Schema struct {
+	drv dialect.Driver
+}
+
+// NewSchema creates a new schema client.
+func NewSchema(drv dialect.Driver) *Schema { return &Schema{drv: drv} }
+
+// Create creates all schema resources.
+func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error {
+	return Create(ctx, s, Tables, opts...)
+}
+
+// Create creates all table resources using the given schema driver.
+func Create(ctx context.Context, s *Schema, tables []*schema.Table, opts ...schema.MigrateOption) error {
+	migrate, err := schema.NewMigrate(s.drv, opts...)
+	if err != nil {
+		return fmt.Errorf("ent/migrate: %w", err)
+	}
+	return migrate.Create(ctx, tables...)
+}
+
+// WriteTo writes the schema changes to w instead of running them against the database.
+//
+//	if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil {
+//		log.Fatal(err)
+//	}
+func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error {
+	return Create(ctx, &Schema{drv: &schema.WriteDriver{Writer: w, Driver: s.drv}}, Tables, opts...)
+}
diff --git a/bj_power_wms/migrate/schema.go b/bj_power_wms/migrate/schema.go
new file mode 100644
index 0000000..e8ce0be
--- /dev/null
+++ b/bj_power_wms/migrate/schema.go
@@ -0,0 +1,856 @@
+// Code generated by ent, DO NOT EDIT.
+
+package migrate
+
+import (
+	"entgo.io/ent/dialect/entsql"
+	"entgo.io/ent/dialect/sql/schema"
+	"entgo.io/ent/schema/field"
+)
+
+var (
+	// AgvTasksColumns holds the columns for the "agv_tasks" table.
+	AgvTasksColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "task_no", Type: field.TypeString, Unique: true, Size: 64},
+		{Name: "hik_task_code", Type: field.TypeString, Size: 64, Default: ""},
+		{Name: "source_dock", Type: field.TypeString, Size: 20, Default: ""},
+		{Name: "target_dock", Type: field.TypeString, Size: 20, Default: ""},
+		{Name: "materials_json", Type: field.TypeString, Size: 4000, Default: ""},
+		{Name: "related_outbound_no", Type: field.TypeString, Nullable: true, Size: 64, Default: ""},
+		{Name: "status", Type: field.TypeString, Size: 20, Default: "PENDING"},
+		{Name: "operator", Type: field.TypeString, Size: 64, Default: ""},
+		{Name: "dispatched_at", Type: field.TypeInt64, Default: 0},
+		{Name: "arrived_at", Type: field.TypeInt64, Default: 0},
+		{Name: "remark", Type: field.TypeString, Nullable: true, Size: 500, Default: ""},
+		{Name: "created_at", Type: field.TypeInt64},
+	}
+	// AgvTasksTable holds the schema information for the "agv_tasks" table.
+	AgvTasksTable = &schema.Table{
+		Name:       "agv_tasks",
+		Columns:    AgvTasksColumns,
+		PrimaryKey: []*schema.Column{AgvTasksColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "agvtask_task_no",
+				Unique:  true,
+				Columns: []*schema.Column{AgvTasksColumns[1]},
+			},
+			{
+				Name:    "agvtask_target_dock",
+				Unique:  false,
+				Columns: []*schema.Column{AgvTasksColumns[4]},
+			},
+			{
+				Name:    "agvtask_status",
+				Unique:  false,
+				Columns: []*schema.Column{AgvTasksColumns[7]},
+			},
+			{
+				Name:    "agvtask_hik_task_code",
+				Unique:  false,
+				Columns: []*schema.Column{AgvTasksColumns[2]},
+			},
+		},
+	}
+	// AttachmentsColumns holds the columns for the "attachments" table.
+	AttachmentsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "biz_type", Type: field.TypeString},
+		{Name: "biz_id", Type: field.TypeString},
+		{Name: "file_name", Type: field.TypeString},
+		{Name: "file_path", Type: field.TypeString},
+		{Name: "file_type", Type: field.TypeString, Nullable: true},
+		{Name: "file_ext", Type: field.TypeString, Nullable: true},
+		{Name: "file_md5", Type: field.TypeString, Nullable: true},
+		{Name: "file_size", Type: field.TypeInt64, Default: 0},
+		{Name: "mime_type", Type: field.TypeString, Nullable: true},
+		{Name: "uploaded_by", Type: field.TypeString, Nullable: true},
+		{Name: "archived", Type: field.TypeBool, Default: false},
+		{Name: "archived_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "deleted", Type: field.TypeBool, Default: false},
+		{Name: "deleted_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "deleted_by", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+	}
+	// AttachmentsTable holds the schema information for the "attachments" table.
+	AttachmentsTable = &schema.Table{
+		Name:       "attachments",
+		Columns:    AttachmentsColumns,
+		PrimaryKey: []*schema.Column{AttachmentsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "attachment_biz_type_biz_id",
+				Unique:  false,
+				Columns: []*schema.Column{AttachmentsColumns[1], AttachmentsColumns[2]},
+			},
+			{
+				Name:    "attachment_file_type",
+				Unique:  false,
+				Columns: []*schema.Column{AttachmentsColumns[5]},
+			},
+			{
+				Name:    "attachment_file_md5",
+				Unique:  false,
+				Columns: []*schema.Column{AttachmentsColumns[7]},
+			},
+			{
+				Name:    "attachment_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{AttachmentsColumns[16]},
+			},
+		},
+	}
+	// EventLogColumns holds the columns for the "event_log" table.
+	EventLogColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "event_type", Type: field.TypeString, Size: 64},
+		{Name: "operator", Type: field.TypeString, Size: 64, Default: ""},
+		{Name: "entity_type", Type: field.TypeString, Size: 32, Default: ""},
+		{Name: "entity_id", Type: field.TypeString, Size: 64, Default: ""},
+		{Name: "description", Type: field.TypeString, Size: 2147483647, Default: ""},
+		{Name: "payload", Type: field.TypeJSON, Nullable: true, SchemaType: map[string]string{"postgres": "jsonb"}},
+		{Name: "created_at", Type: field.TypeInt64},
+	}
+	// EventLogTable holds the schema information for the "event_log" table.
+	EventLogTable = &schema.Table{
+		Name:       "event_log",
+		Columns:    EventLogColumns,
+		PrimaryKey: []*schema.Column{EventLogColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "eventlog_event_type",
+				Unique:  false,
+				Columns: []*schema.Column{EventLogColumns[1]},
+			},
+			{
+				Name:    "eventlog_operator",
+				Unique:  false,
+				Columns: []*schema.Column{EventLogColumns[2]},
+			},
+			{
+				Name:    "eventlog_created_at",
+				Unique:  false,
+				Columns: []*schema.Column{EventLogColumns[7]},
+			},
+		},
+	}
+	// InboundDetailsColumns holds the columns for the "inbound_details" table.
+	InboundDetailsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "inbound_no", Type: field.TypeString},
+		{Name: "sn_code", Type: field.TypeString, Nullable: true},
+		{Name: "batch_no", Type: field.TypeString, Nullable: true},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "quantity", Type: field.TypeInt, Default: 1},
+		{Name: "created_at", Type: field.TypeInt64},
+	}
+	// InboundDetailsTable holds the schema information for the "inbound_details" table.
+	InboundDetailsTable = &schema.Table{
+		Name:       "inbound_details",
+		Columns:    InboundDetailsColumns,
+		PrimaryKey: []*schema.Column{InboundDetailsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "inbounddetail_inbound_no",
+				Unique:  false,
+				Columns: []*schema.Column{InboundDetailsColumns[1]},
+			},
+			{
+				Name:    "inbounddetail_sn_code",
+				Unique:  false,
+				Columns: []*schema.Column{InboundDetailsColumns[2]},
+			},
+		},
+	}
+	// InboundOrdersColumns holds the columns for the "inbound_orders" table.
+	InboundOrdersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "inbound_no", Type: field.TypeString, Unique: true},
+		{Name: "inbound_type", Type: field.TypeString, Default: "purchase"},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "material_name", Type: field.TypeString, Nullable: true},
+		{Name: "manage_mode", Type: field.TypeInt, Default: 1},
+		{Name: "batch_no", Type: field.TypeString, Nullable: true},
+		{Name: "zone_code", Type: field.TypeString, Nullable: true},
+		{Name: "shelf_no", Type: field.TypeString, Nullable: true},
+		{Name: "layer_no", Type: field.TypeString, Nullable: true},
+		{Name: "position_no", Type: field.TypeString, Nullable: true},
+		{Name: "quantity", Type: field.TypeInt, Default: 0},
+		{Name: "operator", Type: field.TypeString, Nullable: true},
+		{Name: "remark", Type: field.TypeString, Nullable: true},
+		{Name: "inspection_no", Type: field.TypeString},
+		{Name: "ownership_type", Type: field.TypeString, Default: "none"},
+		{Name: "ownership_no", Type: field.TypeString, Nullable: true},
+		{Name: "quality_status", Type: field.TypeString, Nullable: true},
+		{Name: "voided", Type: field.TypeBool, Default: false},
+		{Name: "void_reason", Type: field.TypeString, Nullable: true},
+		{Name: "voided_by", Type: field.TypeString, Nullable: true},
+		{Name: "voided_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+	}
+	// InboundOrdersTable holds the schema information for the "inbound_orders" table.
+	InboundOrdersTable = &schema.Table{
+		Name:       "inbound_orders",
+		Columns:    InboundOrdersColumns,
+		PrimaryKey: []*schema.Column{InboundOrdersColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "inboundorder_material_code",
+				Unique:  false,
+				Columns: []*schema.Column{InboundOrdersColumns[3]},
+			},
+			{
+				Name:    "inboundorder_inbound_type",
+				Unique:  false,
+				Columns: []*schema.Column{InboundOrdersColumns[2]},
+			},
+			{
+				Name:    "inboundorder_operator",
+				Unique:  false,
+				Columns: []*schema.Column{InboundOrdersColumns[12]},
+			},
+		},
+	}
+	// InspectionRecordsColumns holds the columns for the "inspection_records" table.
+	InspectionRecordsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "target_type", Type: field.TypeString},
+		{Name: "target_id", Type: field.TypeString},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "material_name", Type: field.TypeString, Nullable: true},
+		{Name: "ownership_type", Type: field.TypeString, Nullable: true},
+		{Name: "ownership_no", Type: field.TypeString, Nullable: true},
+		{Name: "related_standard", Type: field.TypeString, Nullable: true},
+		{Name: "manufacturer", Type: field.TypeString, Nullable: true},
+		{Name: "inspection_type", Type: field.TypeString, Default: "incoming"},
+		{Name: "status", Type: field.TypeString, Default: "未检"},
+		{Name: "result_value", Type: field.TypeString, Nullable: true},
+		{Name: "inspect_qty", Type: field.TypeInt, Default: 0},
+		{Name: "pass_qty", Type: field.TypeInt, Default: 0},
+		{Name: "reject_qty", Type: field.TypeInt, Default: 0},
+		{Name: "check_desc", Type: field.TypeString, Nullable: true},
+		{Name: "inspector", Type: field.TypeString, Nullable: true},
+		{Name: "inspection_no", Type: field.TypeString, Nullable: true},
+		{Name: "report_no", Type: field.TypeString, Nullable: true},
+		{Name: "disposal_type", Type: field.TypeString, Default: "NONE"},
+		{Name: "disposal_remark", Type: field.TypeString, Nullable: true},
+		{Name: "return_tracking_no", Type: field.TypeString, Nullable: true},
+		{Name: "remark", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// InspectionRecordsTable holds the schema information for the "inspection_records" table.
+	InspectionRecordsTable = &schema.Table{
+		Name:       "inspection_records",
+		Columns:    InspectionRecordsColumns,
+		PrimaryKey: []*schema.Column{InspectionRecordsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "inspectionrecord_target_id",
+				Unique:  false,
+				Columns: []*schema.Column{InspectionRecordsColumns[2]},
+			},
+			{
+				Name:    "inspectionrecord_material_code",
+				Unique:  false,
+				Columns: []*schema.Column{InspectionRecordsColumns[3]},
+			},
+			{
+				Name:    "inspectionrecord_inspection_type",
+				Unique:  false,
+				Columns: []*schema.Column{InspectionRecordsColumns[9]},
+			},
+			{
+				Name:    "inspectionrecord_status",
+				Unique:  false,
+				Columns: []*schema.Column{InspectionRecordsColumns[10]},
+			},
+		},
+	}
+	// InventoriesColumns holds the columns for the "inventories" table.
+	InventoriesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "manage_mode", Type: field.TypeInt},
+		{Name: "category", Type: field.TypeInt, Default: 1},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "material_name", Type: field.TypeString, Nullable: true},
+		{Name: "batch_no", Type: field.TypeString, Nullable: true},
+		{Name: "sn_code", Type: field.TypeString, Nullable: true},
+		{Name: "quantity", Type: field.TypeInt, Default: 0},
+		{Name: "locked_qty", Type: field.TypeInt, Default: 0},
+		{Name: "quality_status", Type: field.TypeString, Default: "未检"},
+		{Name: "zone_code", Type: field.TypeString, Nullable: true},
+		{Name: "shelf_no", Type: field.TypeString, Nullable: true},
+		{Name: "layer_no", Type: field.TypeString, Nullable: true},
+		{Name: "position_no", Type: field.TypeString, Nullable: true},
+		{Name: "status", Type: field.TypeString, Default: "在库"},
+		{Name: "production_date", Type: field.TypeString, Nullable: true},
+		{Name: "supplier", Type: field.TypeString, Nullable: true},
+		{Name: "inbound_no", Type: field.TypeString, Nullable: true},
+		{Name: "order_no", Type: field.TypeString, Size: 64, Default: ""},
+		{Name: "completed_process", Type: field.TypeString, Size: 64, Default: ""},
+		{Name: "ownership_type", Type: field.TypeString, Nullable: true},
+		{Name: "ownership_no", Type: field.TypeString, Nullable: true},
+		{Name: "product_status", Type: field.TypeString, Nullable: true},
+		{Name: "related_standard", Type: field.TypeString, Nullable: true},
+		{Name: "test_record_no", Type: field.TypeString, Nullable: true},
+		{Name: "recorded_by", Type: field.TypeString, Nullable: true},
+		{Name: "recorded_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "outbound_reason", Type: field.TypeString, Nullable: true},
+		{Name: "stocktake_no", Type: field.TypeString, Size: 64, Default: ""},
+		{Name: "remark", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// InventoriesTable holds the schema information for the "inventories" table.
+	InventoriesTable = &schema.Table{
+		Name:       "inventories",
+		Columns:    InventoriesColumns,
+		PrimaryKey: []*schema.Column{InventoriesColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "inventory_manage_mode",
+				Unique:  false,
+				Columns: []*schema.Column{InventoriesColumns[1]},
+			},
+			{
+				Name:    "inventory_category",
+				Unique:  false,
+				Columns: []*schema.Column{InventoriesColumns[2]},
+			},
+			{
+				Name:    "inventory_material_code",
+				Unique:  false,
+				Columns: []*schema.Column{InventoriesColumns[3]},
+			},
+			{
+				Name:    "inventory_quality_status",
+				Unique:  false,
+				Columns: []*schema.Column{InventoriesColumns[9]},
+			},
+			{
+				Name:    "inventory_zone_code",
+				Unique:  false,
+				Columns: []*schema.Column{InventoriesColumns[10]},
+			},
+			{
+				Name:    "inventory_batch_no",
+				Unique:  false,
+				Columns: []*schema.Column{InventoriesColumns[5]},
+			},
+			{
+				Name:    "inventory_sn_code",
+				Unique:  false,
+				Columns: []*schema.Column{InventoriesColumns[6]},
+			},
+		},
+	}
+	// InventoryLocksColumns holds the columns for the "inventory_locks" table.
+	InventoryLocksColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "target_type", Type: field.TypeString},
+		{Name: "target_id", Type: field.TypeString},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "locked_qty", Type: field.TypeInt, Default: 1},
+		{Name: "order_no", Type: field.TypeString},
+		{Name: "status", Type: field.TypeString, Default: "ACTIVE"},
+		{Name: "expired_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "remark", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// InventoryLocksTable holds the schema information for the "inventory_locks" table.
+	InventoryLocksTable = &schema.Table{
+		Name:       "inventory_locks",
+		Columns:    InventoryLocksColumns,
+		PrimaryKey: []*schema.Column{InventoryLocksColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "inventorylock_order_no",
+				Unique:  false,
+				Columns: []*schema.Column{InventoryLocksColumns[5]},
+			},
+			{
+				Name:    "inventorylock_status",
+				Unique:  false,
+				Columns: []*schema.Column{InventoryLocksColumns[6]},
+			},
+			{
+				Name:    "inventorylock_target_id",
+				Unique:  false,
+				Columns: []*schema.Column{InventoryLocksColumns[2]},
+			},
+		},
+	}
+	// MaterialsColumns holds the columns for the "materials" table.
+	MaterialsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "code", Type: field.TypeString, Unique: true},
+		{Name: "name", Type: field.TypeString},
+		{Name: "spec", Type: field.TypeString, Nullable: true},
+		{Name: "unit", Type: field.TypeString, Nullable: true},
+		{Name: "description", Type: field.TypeString, Nullable: true},
+		{Name: "item_type", Type: field.TypeInt, Default: 1},
+		{Name: "manage_mode", Type: field.TypeInt, Default: 1},
+		{Name: "is_batch_managed", Type: field.TypeBool, Default: false},
+		{Name: "is_serial_managed", Type: field.TypeBool, Default: false},
+		{Name: "template_code", Type: field.TypeString, Nullable: true},
+		{Name: "safety_stock", Type: field.TypeInt, Default: 0},
+		{Name: "is_active", Type: field.TypeBool, Default: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// MaterialsTable holds the schema information for the "materials" table.
+	MaterialsTable = &schema.Table{
+		Name:       "materials",
+		Columns:    MaterialsColumns,
+		PrimaryKey: []*schema.Column{MaterialsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "material_name",
+				Unique:  false,
+				Columns: []*schema.Column{MaterialsColumns[2]},
+			},
+			{
+				Name:    "material_template_code",
+				Unique:  false,
+				Columns: []*schema.Column{MaterialsColumns[10]},
+			},
+			{
+				Name:    "material_item_type",
+				Unique:  false,
+				Columns: []*schema.Column{MaterialsColumns[6]},
+			},
+		},
+	}
+	// MaterialDemandsColumns holds the columns for the "material_demands" table.
+	MaterialDemandsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "material_code", Type: field.TypeString, Unique: true},
+		{Name: "future5_qty", Type: field.TypeInt, Default: 0},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// MaterialDemandsTable holds the schema information for the "material_demands" table.
+	MaterialDemandsTable = &schema.Table{
+		Name:       "material_demands",
+		Columns:    MaterialDemandsColumns,
+		PrimaryKey: []*schema.Column{MaterialDemandsColumns[0]},
+	}
+	// OrderMaterialLedgersColumns holds the columns for the "order_material_ledgers" table.
+	OrderMaterialLedgersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "order_no", Type: field.TypeString},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "material_name", Type: field.TypeString, Nullable: true},
+		{Name: "total_qty", Type: field.TypeInt, Default: 0},
+		{Name: "out_qty", Type: field.TypeInt, Default: 0},
+		{Name: "returned_qty", Type: field.TypeInt, Default: 0},
+		{Name: "consumed_qty", Type: field.TypeInt, Default: 0},
+		{Name: "status", Type: field.TypeString, Default: "进行中"},
+		{Name: "target_station", Type: field.TypeString, Nullable: true},
+		{Name: "completed_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "remark", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// OrderMaterialLedgersTable holds the schema information for the "order_material_ledgers" table.
+	OrderMaterialLedgersTable = &schema.Table{
+		Name:       "order_material_ledgers",
+		Columns:    OrderMaterialLedgersColumns,
+		PrimaryKey: []*schema.Column{OrderMaterialLedgersColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "ordermaterialledger_order_no",
+				Unique:  false,
+				Columns: []*schema.Column{OrderMaterialLedgersColumns[1]},
+			},
+			{
+				Name:    "ordermaterialledger_material_code",
+				Unique:  false,
+				Columns: []*schema.Column{OrderMaterialLedgersColumns[2]},
+			},
+		},
+	}
+	// OutboundDetailsColumns holds the columns for the "outbound_details" table.
+	OutboundDetailsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "outbound_no", Type: field.TypeString},
+		{Name: "sn_code", Type: field.TypeString, Nullable: true},
+		{Name: "batch_no", Type: field.TypeString, Nullable: true},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "quantity", Type: field.TypeInt, Default: 1},
+		{Name: "order_no", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+	}
+	// OutboundDetailsTable holds the schema information for the "outbound_details" table.
+	OutboundDetailsTable = &schema.Table{
+		Name:       "outbound_details",
+		Columns:    OutboundDetailsColumns,
+		PrimaryKey: []*schema.Column{OutboundDetailsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "outbounddetail_outbound_no",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundDetailsColumns[1]},
+			},
+			{
+				Name:    "outbounddetail_sn_code",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundDetailsColumns[2]},
+			},
+			{
+				Name:    "outbounddetail_order_no",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundDetailsColumns[6]},
+			},
+		},
+	}
+	// OutboundOrdersColumns holds the columns for the "outbound_orders" table.
+	OutboundOrdersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "outbound_no", Type: field.TypeString, Unique: true},
+		{Name: "outbound_type", Type: field.TypeString, Default: "workorder"},
+		{Name: "status", Type: field.TypeString, Default: "已出库"},
+		{Name: "need_agv", Type: field.TypeBool, Default: false},
+		{Name: "outbound_category", Type: field.TypeString, Nullable: true},
+		{Name: "ownership_type", Type: field.TypeString, Nullable: true},
+		{Name: "ownership_no", Type: field.TypeString, Nullable: true},
+		{Name: "target_station", Type: field.TypeString, Nullable: true},
+		{Name: "order_no", Type: field.TypeString, Nullable: true},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "material_name", Type: field.TypeString, Nullable: true},
+		{Name: "manage_mode", Type: field.TypeInt, Default: 1},
+		{Name: "batch_no", Type: field.TypeString, Nullable: true},
+		{Name: "zone_code", Type: field.TypeString, Nullable: true},
+		{Name: "shelf_no", Type: field.TypeString, Nullable: true},
+		{Name: "layer_no", Type: field.TypeString, Nullable: true},
+		{Name: "position_no", Type: field.TypeString, Nullable: true},
+		{Name: "quantity", Type: field.TypeInt, Default: 0},
+		{Name: "operator", Type: field.TypeString, Nullable: true},
+		{Name: "reviewer", Type: field.TypeString, Nullable: true},
+		{Name: "target_dock", Type: field.TypeString, Nullable: true},
+		{Name: "remark", Type: field.TypeString, Nullable: true},
+		{Name: "box_no", Type: field.TypeString, Nullable: true},
+		{Name: "box_sn_list", Type: field.TypeString, Nullable: true},
+		{Name: "contract_no", Type: field.TypeString, Nullable: true},
+		{Name: "inspection_no", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+	}
+	// OutboundOrdersTable holds the schema information for the "outbound_orders" table.
+	OutboundOrdersTable = &schema.Table{
+		Name:       "outbound_orders",
+		Columns:    OutboundOrdersColumns,
+		PrimaryKey: []*schema.Column{OutboundOrdersColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "outboundorder_order_no",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundOrdersColumns[9]},
+			},
+			{
+				Name:    "outboundorder_material_code",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundOrdersColumns[10]},
+			},
+			{
+				Name:    "outboundorder_outbound_type",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundOrdersColumns[2]},
+			},
+			{
+				Name:    "outboundorder_box_no",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundOrdersColumns[23]},
+			},
+			{
+				Name:    "outboundorder_inspection_no",
+				Unique:  false,
+				Columns: []*schema.Column{OutboundOrdersColumns[26]},
+			},
+		},
+	}
+	// PermissionsColumns holds the columns for the "permissions" table.
+	PermissionsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "code", Type: field.TypeString, Unique: true, Size: 64},
+		{Name: "name", Type: field.TypeString, Size: 64},
+		{Name: "type", Type: field.TypeString, Size: 20, Default: "MENU"},
+		{Name: "parent_code", Type: field.TypeString, Nullable: true, Size: 64, Default: ""},
+		{Name: "path", Type: field.TypeString, Nullable: true, Size: 128, Default: ""},
+		{Name: "icon", Type: field.TypeString, Nullable: true, Size: 64, Default: ""},
+		{Name: "sort", Type: field.TypeInt, Nullable: true, Default: 0},
+		{Name: "remark", Type: field.TypeString, Nullable: true, Size: 255, Default: ""},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// PermissionsTable holds the schema information for the "permissions" table.
+	PermissionsTable = &schema.Table{
+		Name:       "permissions",
+		Columns:    PermissionsColumns,
+		PrimaryKey: []*schema.Column{PermissionsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "permission_code",
+				Unique:  true,
+				Columns: []*schema.Column{PermissionsColumns[1]},
+			},
+		},
+	}
+	// ReturnOrdersColumns holds the columns for the "return_orders" table.
+	ReturnOrdersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "return_no", Type: field.TypeString, Unique: true},
+		{Name: "source_type", Type: field.TypeString, Default: "station"},
+		{Name: "order_no", Type: field.TypeString, Default: ""},
+		{Name: "station_no", Type: field.TypeInt, Default: 0},
+		{Name: "sn", Type: field.TypeString, Default: ""},
+		{Name: "material_code", Type: field.TypeString},
+		{Name: "material_name", Type: field.TypeString, Nullable: true},
+		{Name: "spec", Type: field.TypeString, Nullable: true},
+		{Name: "qty", Type: field.TypeInt, Default: 0},
+		{Name: "unit", Type: field.TypeString, Default: ""},
+		{Name: "reason", Type: field.TypeString, Default: ""},
+		{Name: "status", Type: field.TypeString, Default: "PENDING"},
+		{Name: "operator", Type: field.TypeString, Default: ""},
+		{Name: "receive_by", Type: field.TypeString, Default: ""},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "receive_at", Type: field.TypeInt64, Default: 0},
+	}
+	// ReturnOrdersTable holds the schema information for the "return_orders" table.
+	ReturnOrdersTable = &schema.Table{
+		Name:       "return_orders",
+		Columns:    ReturnOrdersColumns,
+		PrimaryKey: []*schema.Column{ReturnOrdersColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "returnorder_status",
+				Unique:  false,
+				Columns: []*schema.Column{ReturnOrdersColumns[12]},
+			},
+			{
+				Name:    "returnorder_order_no",
+				Unique:  false,
+				Columns: []*schema.Column{ReturnOrdersColumns[3]},
+			},
+			{
+				Name:    "returnorder_station_no",
+				Unique:  false,
+				Columns: []*schema.Column{ReturnOrdersColumns[4]},
+			},
+			{
+				Name:    "returnorder_material_code",
+				Unique:  false,
+				Columns: []*schema.Column{ReturnOrdersColumns[6]},
+			},
+		},
+	}
+	// RolesColumns holds the columns for the "roles" table.
+	RolesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "name", Type: field.TypeString, Size: 64},
+		{Name: "code", Type: field.TypeString, Unique: true, Size: 64},
+		{Name: "remark", Type: field.TypeString, Nullable: true, Size: 255, Default: ""},
+		{Name: "permission_codes", Type: field.TypeJSON, Nullable: true, SchemaType: map[string]string{"postgres": "jsonb"}},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// RolesTable holds the schema information for the "roles" table.
+	RolesTable = &schema.Table{
+		Name:       "roles",
+		Columns:    RolesColumns,
+		PrimaryKey: []*schema.Column{RolesColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "role_code",
+				Unique:  true,
+				Columns: []*schema.Column{RolesColumns[2]},
+			},
+		},
+	}
+	// SemiFinishedsColumns holds the columns for the "semi_finisheds" table.
+	SemiFinishedsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "sn", Type: field.TypeString, Unique: true},
+		{Name: "material_code", Type: field.TypeString, Nullable: true},
+		{Name: "completed_process", Type: field.TypeString, Nullable: true},
+		{Name: "quantity", Type: field.TypeInt, Default: 1},
+		{Name: "zone_code", Type: field.TypeString, Nullable: true},
+		{Name: "status", Type: field.TypeString, Default: "在库"},
+		{Name: "order_no", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// SemiFinishedsTable holds the schema information for the "semi_finisheds" table.
+	SemiFinishedsTable = &schema.Table{
+		Name:       "semi_finisheds",
+		Columns:    SemiFinishedsColumns,
+		PrimaryKey: []*schema.Column{SemiFinishedsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "semifinished_material_code",
+				Unique:  false,
+				Columns: []*schema.Column{SemiFinishedsColumns[2]},
+			},
+			{
+				Name:    "semifinished_status",
+				Unique:  false,
+				Columns: []*schema.Column{SemiFinishedsColumns[6]},
+			},
+		},
+	}
+	// StocktakeItemsColumns holds the columns for the "stocktake_items" table.
+	StocktakeItemsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "stocktake_no", Type: field.TypeString},
+		{Name: "target_type", Type: field.TypeString},
+		{Name: "target_id", Type: field.TypeString},
+		{Name: "material_code", Type: field.TypeString, Nullable: true},
+		{Name: "zone_code", Type: field.TypeString, Nullable: true},
+		{Name: "shelf_no", Type: field.TypeString, Nullable: true},
+		{Name: "layer_no", Type: field.TypeString, Nullable: true},
+		{Name: "position_no", Type: field.TypeString, Nullable: true},
+		{Name: "book_qty", Type: field.TypeInt, Default: 0},
+		{Name: "scanned_qty", Type: field.TypeInt, Default: -1},
+		{Name: "diff_qty", Type: field.TypeInt, Default: 0},
+		{Name: "counted", Type: field.TypeBool, Default: false},
+		{Name: "counted_by", Type: field.TypeString, Nullable: true},
+		{Name: "counted_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// StocktakeItemsTable holds the schema information for the "stocktake_items" table.
+	StocktakeItemsTable = &schema.Table{
+		Name:       "stocktake_items",
+		Columns:    StocktakeItemsColumns,
+		PrimaryKey: []*schema.Column{StocktakeItemsColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "stocktakeitem_stocktake_no",
+				Unique:  false,
+				Columns: []*schema.Column{StocktakeItemsColumns[1]},
+			},
+			{
+				Name:    "stocktakeitem_target_id",
+				Unique:  false,
+				Columns: []*schema.Column{StocktakeItemsColumns[3]},
+			},
+		},
+	}
+	// StocktakeOrdersColumns holds the columns for the "stocktake_orders" table.
+	StocktakeOrdersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "stocktake_no", Type: field.TypeString, Unique: true},
+		{Name: "status", Type: field.TypeString, Default: "进行中"},
+		{Name: "operator", Type: field.TypeString, Nullable: true},
+		{Name: "total_targets", Type: field.TypeInt, Default: 0},
+		{Name: "diff_count", Type: field.TypeInt, Default: 0},
+		{Name: "adjusted", Type: field.TypeBool, Default: false},
+		{Name: "adjust_no", Type: field.TypeString, Nullable: true},
+		{Name: "written_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "written_by", Type: field.TypeString, Nullable: true},
+		{Name: "uncounted_mode", Type: field.TypeString, Nullable: true},
+		{Name: "cancel_reason", Type: field.TypeString, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "finished_at", Type: field.TypeInt64, Nullable: true},
+	}
+	// StocktakeOrdersTable holds the schema information for the "stocktake_orders" table.
+	StocktakeOrdersTable = &schema.Table{
+		Name:       "stocktake_orders",
+		Columns:    StocktakeOrdersColumns,
+		PrimaryKey: []*schema.Column{StocktakeOrdersColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "stocktakeorder_status",
+				Unique:  false,
+				Columns: []*schema.Column{StocktakeOrdersColumns[2]},
+			},
+		},
+	}
+	// UsersColumns holds the columns for the "users" table.
+	UsersColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "username", Type: field.TypeString, Unique: true},
+		{Name: "password", Type: field.TypeString},
+		{Name: "real_name", Type: field.TypeString, Nullable: true},
+		{Name: "role", Type: field.TypeString, Default: "operator"},
+		{Name: "role_id", Type: field.TypeInt, Nullable: true},
+		{Name: "dept", Type: field.TypeString, Nullable: true},
+		{Name: "phone", Type: field.TypeString, Nullable: true},
+		{Name: "is_active", Type: field.TypeBool, Default: true},
+		{Name: "last_login_at", Type: field.TypeInt64, Nullable: true},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64},
+	}
+	// UsersTable holds the schema information for the "users" table.
+	UsersTable = &schema.Table{
+		Name:       "users",
+		Columns:    UsersColumns,
+		PrimaryKey: []*schema.Column{UsersColumns[0]},
+		Indexes: []*schema.Index{
+			{
+				Name:    "user_role",
+				Unique:  false,
+				Columns: []*schema.Column{UsersColumns[4]},
+			},
+		},
+	}
+	// ZonesColumns holds the columns for the "zones" table.
+	ZonesColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "level", Type: field.TypeInt},
+		{Name: "code", Type: field.TypeString},
+		{Name: "name", Type: field.TypeString, Nullable: true},
+		{Name: "parent_code", Type: field.TypeString, Nullable: true},
+		{Name: "zone_code", Type: field.TypeString},
+		{Name: "zone_name", Type: field.TypeString, Nullable: true},
+		{Name: "description", Type: field.TypeString, Nullable: true},
+		{Name: "shelf_no", Type: field.TypeString, Nullable: true},
+		{Name: "layer_no", Type: field.TypeString, Nullable: true},
+		{Name: "position_no", Type: field.TypeString, Nullable: true},
+		{Name: "status", Type: field.TypeString, Default: "启用"},
+		{Name: "created_at", Type: field.TypeInt64},
+		{Name: "updated_at", Type: field.TypeInt64, Nullable: true},
+	}
+	// ZonesTable holds the schema information for the "zones" table.
+	ZonesTable = &schema.Table{
+		Name:       "zones",
+		Columns:    ZonesColumns,
+		PrimaryKey: []*schema.Column{ZonesColumns[0]},
+	}
+	// Tables holds all the tables in the schema.
+	Tables = []*schema.Table{
+		AgvTasksTable,
+		AttachmentsTable,
+		EventLogTable,
+		InboundDetailsTable,
+		InboundOrdersTable,
+		InspectionRecordsTable,
+		InventoriesTable,
+		InventoryLocksTable,
+		MaterialsTable,
+		MaterialDemandsTable,
+		OrderMaterialLedgersTable,
+		OutboundDetailsTable,
+		OutboundOrdersTable,
+		PermissionsTable,
+		ReturnOrdersTable,
+		RolesTable,
+		SemiFinishedsTable,
+		StocktakeItemsTable,
+		StocktakeOrdersTable,
+		UsersTable,
+		ZonesTable,
+	}
+)
+
+func init() {
+	EventLogTable.Annotation = &entsql.Annotation{
+		Table: "event_log",
+	}
+	PermissionsTable.Annotation = &entsql.Annotation{
+		Table: "permissions",
+	}
+	RolesTable.Annotation = &entsql.Annotation{
+		Table: "roles",
+	}
+}
diff --git a/bj_power_wms/ordermaterialledger/ordermaterialledger.go b/bj_power_wms/ordermaterialledger/ordermaterialledger.go
new file mode 100644
index 0000000..ae59c66
--- /dev/null
+++ b/bj_power_wms/ordermaterialledger/ordermaterialledger.go
@@ -0,0 +1,160 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ordermaterialledger
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the ordermaterialledger type in the database.
+	Label = "order_material_ledger"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldOrderNo holds the string denoting the order_no field in the database.
+	FieldOrderNo = "order_no"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldMaterialName holds the string denoting the material_name field in the database.
+	FieldMaterialName = "material_name"
+	// FieldTotalQty holds the string denoting the total_qty field in the database.
+	FieldTotalQty = "total_qty"
+	// FieldOutQty holds the string denoting the out_qty field in the database.
+	FieldOutQty = "out_qty"
+	// FieldReturnedQty holds the string denoting the returned_qty field in the database.
+	FieldReturnedQty = "returned_qty"
+	// FieldConsumedQty holds the string denoting the consumed_qty field in the database.
+	FieldConsumedQty = "consumed_qty"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldTargetStation holds the string denoting the target_station field in the database.
+	FieldTargetStation = "target_station"
+	// FieldCompletedAt holds the string denoting the completed_at field in the database.
+	FieldCompletedAt = "completed_at"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the ordermaterialledger in the database.
+	Table = "order_material_ledgers"
+)
+
+// Columns holds all SQL columns for ordermaterialledger fields.
+var Columns = []string{
+	FieldID,
+	FieldOrderNo,
+	FieldMaterialCode,
+	FieldMaterialName,
+	FieldTotalQty,
+	FieldOutQty,
+	FieldReturnedQty,
+	FieldConsumedQty,
+	FieldStatus,
+	FieldTargetStation,
+	FieldCompletedAt,
+	FieldRemark,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultTotalQty holds the default value on creation for the "total_qty" field.
+	DefaultTotalQty int
+	// DefaultOutQty holds the default value on creation for the "out_qty" field.
+	DefaultOutQty int
+	// DefaultReturnedQty holds the default value on creation for the "returned_qty" field.
+	DefaultReturnedQty int
+	// DefaultConsumedQty holds the default value on creation for the "consumed_qty" field.
+	DefaultConsumedQty int
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the OrderMaterialLedger queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByOrderNo orders the results by the order_no field.
+func ByOrderNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOrderNo, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByMaterialName orders the results by the material_name field.
+func ByMaterialName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialName, opts...).ToFunc()
+}
+
+// ByTotalQty orders the results by the total_qty field.
+func ByTotalQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTotalQty, opts...).ToFunc()
+}
+
+// ByOutQty orders the results by the out_qty field.
+func ByOutQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOutQty, opts...).ToFunc()
+}
+
+// ByReturnedQty orders the results by the returned_qty field.
+func ByReturnedQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReturnedQty, opts...).ToFunc()
+}
+
+// ByConsumedQty orders the results by the consumed_qty field.
+func ByConsumedQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldConsumedQty, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByTargetStation orders the results by the target_station field.
+func ByTargetStation(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetStation, opts...).ToFunc()
+}
+
+// ByCompletedAt orders the results by the completed_at field.
+func ByCompletedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCompletedAt, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/ordermaterialledger/where.go b/bj_power_wms/ordermaterialledger/where.go
new file mode 100644
index 0000000..80f25ac
--- /dev/null
+++ b/bj_power_wms/ordermaterialledger/where.go
@@ -0,0 +1,844 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ordermaterialledger
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldID, id))
+}
+
+// OrderNo applies equality check predicate on the "order_no" field. It's identical to OrderNoEQ.
+func OrderNo(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialName applies equality check predicate on the "material_name" field. It's identical to MaterialNameEQ.
+func MaterialName(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// TotalQty applies equality check predicate on the "total_qty" field. It's identical to TotalQtyEQ.
+func TotalQty(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldTotalQty, v))
+}
+
+// OutQty applies equality check predicate on the "out_qty" field. It's identical to OutQtyEQ.
+func OutQty(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldOutQty, v))
+}
+
+// ReturnedQty applies equality check predicate on the "returned_qty" field. It's identical to ReturnedQtyEQ.
+func ReturnedQty(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldReturnedQty, v))
+}
+
+// ConsumedQty applies equality check predicate on the "consumed_qty" field. It's identical to ConsumedQtyEQ.
+func ConsumedQty(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldConsumedQty, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldStatus, v))
+}
+
+// TargetStation applies equality check predicate on the "target_station" field. It's identical to TargetStationEQ.
+func TargetStation(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldTargetStation, v))
+}
+
+// CompletedAt applies equality check predicate on the "completed_at" field. It's identical to CompletedAtEQ.
+func CompletedAt(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldCompletedAt, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldRemark, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// OrderNoEQ applies the EQ predicate on the "order_no" field.
+func OrderNoEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// OrderNoNEQ applies the NEQ predicate on the "order_no" field.
+func OrderNoNEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldOrderNo, v))
+}
+
+// OrderNoIn applies the In predicate on the "order_no" field.
+func OrderNoIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldOrderNo, vs...))
+}
+
+// OrderNoNotIn applies the NotIn predicate on the "order_no" field.
+func OrderNoNotIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldOrderNo, vs...))
+}
+
+// OrderNoGT applies the GT predicate on the "order_no" field.
+func OrderNoGT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldOrderNo, v))
+}
+
+// OrderNoGTE applies the GTE predicate on the "order_no" field.
+func OrderNoGTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldOrderNo, v))
+}
+
+// OrderNoLT applies the LT predicate on the "order_no" field.
+func OrderNoLT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldOrderNo, v))
+}
+
+// OrderNoLTE applies the LTE predicate on the "order_no" field.
+func OrderNoLTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldOrderNo, v))
+}
+
+// OrderNoContains applies the Contains predicate on the "order_no" field.
+func OrderNoContains(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContains(FieldOrderNo, v))
+}
+
+// OrderNoHasPrefix applies the HasPrefix predicate on the "order_no" field.
+func OrderNoHasPrefix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasPrefix(FieldOrderNo, v))
+}
+
+// OrderNoHasSuffix applies the HasSuffix predicate on the "order_no" field.
+func OrderNoHasSuffix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasSuffix(FieldOrderNo, v))
+}
+
+// OrderNoEqualFold applies the EqualFold predicate on the "order_no" field.
+func OrderNoEqualFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEqualFold(FieldOrderNo, v))
+}
+
+// OrderNoContainsFold applies the ContainsFold predicate on the "order_no" field.
+func OrderNoContainsFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContainsFold(FieldOrderNo, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// MaterialNameEQ applies the EQ predicate on the "material_name" field.
+func MaterialNameEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// MaterialNameNEQ applies the NEQ predicate on the "material_name" field.
+func MaterialNameNEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldMaterialName, v))
+}
+
+// MaterialNameIn applies the In predicate on the "material_name" field.
+func MaterialNameIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameNotIn applies the NotIn predicate on the "material_name" field.
+func MaterialNameNotIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameGT applies the GT predicate on the "material_name" field.
+func MaterialNameGT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldMaterialName, v))
+}
+
+// MaterialNameGTE applies the GTE predicate on the "material_name" field.
+func MaterialNameGTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldMaterialName, v))
+}
+
+// MaterialNameLT applies the LT predicate on the "material_name" field.
+func MaterialNameLT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldMaterialName, v))
+}
+
+// MaterialNameLTE applies the LTE predicate on the "material_name" field.
+func MaterialNameLTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldMaterialName, v))
+}
+
+// MaterialNameContains applies the Contains predicate on the "material_name" field.
+func MaterialNameContains(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContains(FieldMaterialName, v))
+}
+
+// MaterialNameHasPrefix applies the HasPrefix predicate on the "material_name" field.
+func MaterialNameHasPrefix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasPrefix(FieldMaterialName, v))
+}
+
+// MaterialNameHasSuffix applies the HasSuffix predicate on the "material_name" field.
+func MaterialNameHasSuffix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasSuffix(FieldMaterialName, v))
+}
+
+// MaterialNameIsNil applies the IsNil predicate on the "material_name" field.
+func MaterialNameIsNil() predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIsNull(FieldMaterialName))
+}
+
+// MaterialNameNotNil applies the NotNil predicate on the "material_name" field.
+func MaterialNameNotNil() predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotNull(FieldMaterialName))
+}
+
+// MaterialNameEqualFold applies the EqualFold predicate on the "material_name" field.
+func MaterialNameEqualFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEqualFold(FieldMaterialName, v))
+}
+
+// MaterialNameContainsFold applies the ContainsFold predicate on the "material_name" field.
+func MaterialNameContainsFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContainsFold(FieldMaterialName, v))
+}
+
+// TotalQtyEQ applies the EQ predicate on the "total_qty" field.
+func TotalQtyEQ(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldTotalQty, v))
+}
+
+// TotalQtyNEQ applies the NEQ predicate on the "total_qty" field.
+func TotalQtyNEQ(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldTotalQty, v))
+}
+
+// TotalQtyIn applies the In predicate on the "total_qty" field.
+func TotalQtyIn(vs ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldTotalQty, vs...))
+}
+
+// TotalQtyNotIn applies the NotIn predicate on the "total_qty" field.
+func TotalQtyNotIn(vs ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldTotalQty, vs...))
+}
+
+// TotalQtyGT applies the GT predicate on the "total_qty" field.
+func TotalQtyGT(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldTotalQty, v))
+}
+
+// TotalQtyGTE applies the GTE predicate on the "total_qty" field.
+func TotalQtyGTE(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldTotalQty, v))
+}
+
+// TotalQtyLT applies the LT predicate on the "total_qty" field.
+func TotalQtyLT(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldTotalQty, v))
+}
+
+// TotalQtyLTE applies the LTE predicate on the "total_qty" field.
+func TotalQtyLTE(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldTotalQty, v))
+}
+
+// OutQtyEQ applies the EQ predicate on the "out_qty" field.
+func OutQtyEQ(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldOutQty, v))
+}
+
+// OutQtyNEQ applies the NEQ predicate on the "out_qty" field.
+func OutQtyNEQ(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldOutQty, v))
+}
+
+// OutQtyIn applies the In predicate on the "out_qty" field.
+func OutQtyIn(vs ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldOutQty, vs...))
+}
+
+// OutQtyNotIn applies the NotIn predicate on the "out_qty" field.
+func OutQtyNotIn(vs ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldOutQty, vs...))
+}
+
+// OutQtyGT applies the GT predicate on the "out_qty" field.
+func OutQtyGT(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldOutQty, v))
+}
+
+// OutQtyGTE applies the GTE predicate on the "out_qty" field.
+func OutQtyGTE(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldOutQty, v))
+}
+
+// OutQtyLT applies the LT predicate on the "out_qty" field.
+func OutQtyLT(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldOutQty, v))
+}
+
+// OutQtyLTE applies the LTE predicate on the "out_qty" field.
+func OutQtyLTE(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldOutQty, v))
+}
+
+// ReturnedQtyEQ applies the EQ predicate on the "returned_qty" field.
+func ReturnedQtyEQ(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldReturnedQty, v))
+}
+
+// ReturnedQtyNEQ applies the NEQ predicate on the "returned_qty" field.
+func ReturnedQtyNEQ(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldReturnedQty, v))
+}
+
+// ReturnedQtyIn applies the In predicate on the "returned_qty" field.
+func ReturnedQtyIn(vs ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldReturnedQty, vs...))
+}
+
+// ReturnedQtyNotIn applies the NotIn predicate on the "returned_qty" field.
+func ReturnedQtyNotIn(vs ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldReturnedQty, vs...))
+}
+
+// ReturnedQtyGT applies the GT predicate on the "returned_qty" field.
+func ReturnedQtyGT(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldReturnedQty, v))
+}
+
+// ReturnedQtyGTE applies the GTE predicate on the "returned_qty" field.
+func ReturnedQtyGTE(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldReturnedQty, v))
+}
+
+// ReturnedQtyLT applies the LT predicate on the "returned_qty" field.
+func ReturnedQtyLT(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldReturnedQty, v))
+}
+
+// ReturnedQtyLTE applies the LTE predicate on the "returned_qty" field.
+func ReturnedQtyLTE(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldReturnedQty, v))
+}
+
+// ConsumedQtyEQ applies the EQ predicate on the "consumed_qty" field.
+func ConsumedQtyEQ(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldConsumedQty, v))
+}
+
+// ConsumedQtyNEQ applies the NEQ predicate on the "consumed_qty" field.
+func ConsumedQtyNEQ(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldConsumedQty, v))
+}
+
+// ConsumedQtyIn applies the In predicate on the "consumed_qty" field.
+func ConsumedQtyIn(vs ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldConsumedQty, vs...))
+}
+
+// ConsumedQtyNotIn applies the NotIn predicate on the "consumed_qty" field.
+func ConsumedQtyNotIn(vs ...int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldConsumedQty, vs...))
+}
+
+// ConsumedQtyGT applies the GT predicate on the "consumed_qty" field.
+func ConsumedQtyGT(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldConsumedQty, v))
+}
+
+// ConsumedQtyGTE applies the GTE predicate on the "consumed_qty" field.
+func ConsumedQtyGTE(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldConsumedQty, v))
+}
+
+// ConsumedQtyLT applies the LT predicate on the "consumed_qty" field.
+func ConsumedQtyLT(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldConsumedQty, v))
+}
+
+// ConsumedQtyLTE applies the LTE predicate on the "consumed_qty" field.
+func ConsumedQtyLTE(v int) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldConsumedQty, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// TargetStationEQ applies the EQ predicate on the "target_station" field.
+func TargetStationEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldTargetStation, v))
+}
+
+// TargetStationNEQ applies the NEQ predicate on the "target_station" field.
+func TargetStationNEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldTargetStation, v))
+}
+
+// TargetStationIn applies the In predicate on the "target_station" field.
+func TargetStationIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldTargetStation, vs...))
+}
+
+// TargetStationNotIn applies the NotIn predicate on the "target_station" field.
+func TargetStationNotIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldTargetStation, vs...))
+}
+
+// TargetStationGT applies the GT predicate on the "target_station" field.
+func TargetStationGT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldTargetStation, v))
+}
+
+// TargetStationGTE applies the GTE predicate on the "target_station" field.
+func TargetStationGTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldTargetStation, v))
+}
+
+// TargetStationLT applies the LT predicate on the "target_station" field.
+func TargetStationLT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldTargetStation, v))
+}
+
+// TargetStationLTE applies the LTE predicate on the "target_station" field.
+func TargetStationLTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldTargetStation, v))
+}
+
+// TargetStationContains applies the Contains predicate on the "target_station" field.
+func TargetStationContains(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContains(FieldTargetStation, v))
+}
+
+// TargetStationHasPrefix applies the HasPrefix predicate on the "target_station" field.
+func TargetStationHasPrefix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasPrefix(FieldTargetStation, v))
+}
+
+// TargetStationHasSuffix applies the HasSuffix predicate on the "target_station" field.
+func TargetStationHasSuffix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasSuffix(FieldTargetStation, v))
+}
+
+// TargetStationIsNil applies the IsNil predicate on the "target_station" field.
+func TargetStationIsNil() predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIsNull(FieldTargetStation))
+}
+
+// TargetStationNotNil applies the NotNil predicate on the "target_station" field.
+func TargetStationNotNil() predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotNull(FieldTargetStation))
+}
+
+// TargetStationEqualFold applies the EqualFold predicate on the "target_station" field.
+func TargetStationEqualFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEqualFold(FieldTargetStation, v))
+}
+
+// TargetStationContainsFold applies the ContainsFold predicate on the "target_station" field.
+func TargetStationContainsFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContainsFold(FieldTargetStation, v))
+}
+
+// CompletedAtEQ applies the EQ predicate on the "completed_at" field.
+func CompletedAtEQ(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldCompletedAt, v))
+}
+
+// CompletedAtNEQ applies the NEQ predicate on the "completed_at" field.
+func CompletedAtNEQ(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldCompletedAt, v))
+}
+
+// CompletedAtIn applies the In predicate on the "completed_at" field.
+func CompletedAtIn(vs ...int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldCompletedAt, vs...))
+}
+
+// CompletedAtNotIn applies the NotIn predicate on the "completed_at" field.
+func CompletedAtNotIn(vs ...int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldCompletedAt, vs...))
+}
+
+// CompletedAtGT applies the GT predicate on the "completed_at" field.
+func CompletedAtGT(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldCompletedAt, v))
+}
+
+// CompletedAtGTE applies the GTE predicate on the "completed_at" field.
+func CompletedAtGTE(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldCompletedAt, v))
+}
+
+// CompletedAtLT applies the LT predicate on the "completed_at" field.
+func CompletedAtLT(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldCompletedAt, v))
+}
+
+// CompletedAtLTE applies the LTE predicate on the "completed_at" field.
+func CompletedAtLTE(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldCompletedAt, v))
+}
+
+// CompletedAtIsNil applies the IsNil predicate on the "completed_at" field.
+func CompletedAtIsNil() predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIsNull(FieldCompletedAt))
+}
+
+// CompletedAtNotNil applies the NotNil predicate on the "completed_at" field.
+func CompletedAtNotNil() predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotNull(FieldCompletedAt))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.OrderMaterialLedger) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.OrderMaterialLedger) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.OrderMaterialLedger) predicate.OrderMaterialLedger {
+	return predicate.OrderMaterialLedger(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/outbounddetail/outbounddetail.go b/bj_power_wms/outbounddetail/outbounddetail.go
new file mode 100644
index 0000000..43f30e1
--- /dev/null
+++ b/bj_power_wms/outbounddetail/outbounddetail.go
@@ -0,0 +1,102 @@
+// Code generated by ent, DO NOT EDIT.
+
+package outbounddetail
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the outbounddetail type in the database.
+	Label = "outbound_detail"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldOutboundNo holds the string denoting the outbound_no field in the database.
+	FieldOutboundNo = "outbound_no"
+	// FieldSnCode holds the string denoting the sn_code field in the database.
+	FieldSnCode = "sn_code"
+	// FieldBatchNo holds the string denoting the batch_no field in the database.
+	FieldBatchNo = "batch_no"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldQuantity holds the string denoting the quantity field in the database.
+	FieldQuantity = "quantity"
+	// FieldOrderNo holds the string denoting the order_no field in the database.
+	FieldOrderNo = "order_no"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// Table holds the table name of the outbounddetail in the database.
+	Table = "outbound_details"
+)
+
+// Columns holds all SQL columns for outbounddetail fields.
+var Columns = []string{
+	FieldID,
+	FieldOutboundNo,
+	FieldSnCode,
+	FieldBatchNo,
+	FieldMaterialCode,
+	FieldQuantity,
+	FieldOrderNo,
+	FieldCreatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultQuantity holds the default value on creation for the "quantity" field.
+	DefaultQuantity int
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the OutboundDetail queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByOutboundNo orders the results by the outbound_no field.
+func ByOutboundNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOutboundNo, opts...).ToFunc()
+}
+
+// BySnCode orders the results by the sn_code field.
+func BySnCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSnCode, opts...).ToFunc()
+}
+
+// ByBatchNo orders the results by the batch_no field.
+func ByBatchNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBatchNo, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByQuantity orders the results by the quantity field.
+func ByQuantity(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQuantity, opts...).ToFunc()
+}
+
+// ByOrderNo orders the results by the order_no field.
+func ByOrderNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOrderNo, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/outbounddetail/where.go b/bj_power_wms/outbounddetail/where.go
new file mode 100644
index 0000000..03777c8
--- /dev/null
+++ b/bj_power_wms/outbounddetail/where.go
@@ -0,0 +1,539 @@
+// Code generated by ent, DO NOT EDIT.
+
+package outbounddetail
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLTE(FieldID, id))
+}
+
+// OutboundNo applies equality check predicate on the "outbound_no" field. It's identical to OutboundNoEQ.
+func OutboundNo(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldOutboundNo, v))
+}
+
+// SnCode applies equality check predicate on the "sn_code" field. It's identical to SnCodeEQ.
+func SnCode(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldSnCode, v))
+}
+
+// BatchNo applies equality check predicate on the "batch_no" field. It's identical to BatchNoEQ.
+func BatchNo(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// Quantity applies equality check predicate on the "quantity" field. It's identical to QuantityEQ.
+func Quantity(v int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldQuantity, v))
+}
+
+// OrderNo applies equality check predicate on the "order_no" field. It's identical to OrderNoEQ.
+func OrderNo(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// OutboundNoEQ applies the EQ predicate on the "outbound_no" field.
+func OutboundNoEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldOutboundNo, v))
+}
+
+// OutboundNoNEQ applies the NEQ predicate on the "outbound_no" field.
+func OutboundNoNEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNEQ(FieldOutboundNo, v))
+}
+
+// OutboundNoIn applies the In predicate on the "outbound_no" field.
+func OutboundNoIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIn(FieldOutboundNo, vs...))
+}
+
+// OutboundNoNotIn applies the NotIn predicate on the "outbound_no" field.
+func OutboundNoNotIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotIn(FieldOutboundNo, vs...))
+}
+
+// OutboundNoGT applies the GT predicate on the "outbound_no" field.
+func OutboundNoGT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGT(FieldOutboundNo, v))
+}
+
+// OutboundNoGTE applies the GTE predicate on the "outbound_no" field.
+func OutboundNoGTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGTE(FieldOutboundNo, v))
+}
+
+// OutboundNoLT applies the LT predicate on the "outbound_no" field.
+func OutboundNoLT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLT(FieldOutboundNo, v))
+}
+
+// OutboundNoLTE applies the LTE predicate on the "outbound_no" field.
+func OutboundNoLTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLTE(FieldOutboundNo, v))
+}
+
+// OutboundNoContains applies the Contains predicate on the "outbound_no" field.
+func OutboundNoContains(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContains(FieldOutboundNo, v))
+}
+
+// OutboundNoHasPrefix applies the HasPrefix predicate on the "outbound_no" field.
+func OutboundNoHasPrefix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasPrefix(FieldOutboundNo, v))
+}
+
+// OutboundNoHasSuffix applies the HasSuffix predicate on the "outbound_no" field.
+func OutboundNoHasSuffix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasSuffix(FieldOutboundNo, v))
+}
+
+// OutboundNoEqualFold applies the EqualFold predicate on the "outbound_no" field.
+func OutboundNoEqualFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEqualFold(FieldOutboundNo, v))
+}
+
+// OutboundNoContainsFold applies the ContainsFold predicate on the "outbound_no" field.
+func OutboundNoContainsFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContainsFold(FieldOutboundNo, v))
+}
+
+// SnCodeEQ applies the EQ predicate on the "sn_code" field.
+func SnCodeEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldSnCode, v))
+}
+
+// SnCodeNEQ applies the NEQ predicate on the "sn_code" field.
+func SnCodeNEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNEQ(FieldSnCode, v))
+}
+
+// SnCodeIn applies the In predicate on the "sn_code" field.
+func SnCodeIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIn(FieldSnCode, vs...))
+}
+
+// SnCodeNotIn applies the NotIn predicate on the "sn_code" field.
+func SnCodeNotIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotIn(FieldSnCode, vs...))
+}
+
+// SnCodeGT applies the GT predicate on the "sn_code" field.
+func SnCodeGT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGT(FieldSnCode, v))
+}
+
+// SnCodeGTE applies the GTE predicate on the "sn_code" field.
+func SnCodeGTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGTE(FieldSnCode, v))
+}
+
+// SnCodeLT applies the LT predicate on the "sn_code" field.
+func SnCodeLT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLT(FieldSnCode, v))
+}
+
+// SnCodeLTE applies the LTE predicate on the "sn_code" field.
+func SnCodeLTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLTE(FieldSnCode, v))
+}
+
+// SnCodeContains applies the Contains predicate on the "sn_code" field.
+func SnCodeContains(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContains(FieldSnCode, v))
+}
+
+// SnCodeHasPrefix applies the HasPrefix predicate on the "sn_code" field.
+func SnCodeHasPrefix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasPrefix(FieldSnCode, v))
+}
+
+// SnCodeHasSuffix applies the HasSuffix predicate on the "sn_code" field.
+func SnCodeHasSuffix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasSuffix(FieldSnCode, v))
+}
+
+// SnCodeIsNil applies the IsNil predicate on the "sn_code" field.
+func SnCodeIsNil() predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIsNull(FieldSnCode))
+}
+
+// SnCodeNotNil applies the NotNil predicate on the "sn_code" field.
+func SnCodeNotNil() predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotNull(FieldSnCode))
+}
+
+// SnCodeEqualFold applies the EqualFold predicate on the "sn_code" field.
+func SnCodeEqualFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEqualFold(FieldSnCode, v))
+}
+
+// SnCodeContainsFold applies the ContainsFold predicate on the "sn_code" field.
+func SnCodeContainsFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContainsFold(FieldSnCode, v))
+}
+
+// BatchNoEQ applies the EQ predicate on the "batch_no" field.
+func BatchNoEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// BatchNoNEQ applies the NEQ predicate on the "batch_no" field.
+func BatchNoNEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNEQ(FieldBatchNo, v))
+}
+
+// BatchNoIn applies the In predicate on the "batch_no" field.
+func BatchNoIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIn(FieldBatchNo, vs...))
+}
+
+// BatchNoNotIn applies the NotIn predicate on the "batch_no" field.
+func BatchNoNotIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotIn(FieldBatchNo, vs...))
+}
+
+// BatchNoGT applies the GT predicate on the "batch_no" field.
+func BatchNoGT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGT(FieldBatchNo, v))
+}
+
+// BatchNoGTE applies the GTE predicate on the "batch_no" field.
+func BatchNoGTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGTE(FieldBatchNo, v))
+}
+
+// BatchNoLT applies the LT predicate on the "batch_no" field.
+func BatchNoLT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLT(FieldBatchNo, v))
+}
+
+// BatchNoLTE applies the LTE predicate on the "batch_no" field.
+func BatchNoLTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLTE(FieldBatchNo, v))
+}
+
+// BatchNoContains applies the Contains predicate on the "batch_no" field.
+func BatchNoContains(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContains(FieldBatchNo, v))
+}
+
+// BatchNoHasPrefix applies the HasPrefix predicate on the "batch_no" field.
+func BatchNoHasPrefix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasPrefix(FieldBatchNo, v))
+}
+
+// BatchNoHasSuffix applies the HasSuffix predicate on the "batch_no" field.
+func BatchNoHasSuffix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasSuffix(FieldBatchNo, v))
+}
+
+// BatchNoIsNil applies the IsNil predicate on the "batch_no" field.
+func BatchNoIsNil() predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIsNull(FieldBatchNo))
+}
+
+// BatchNoNotNil applies the NotNil predicate on the "batch_no" field.
+func BatchNoNotNil() predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotNull(FieldBatchNo))
+}
+
+// BatchNoEqualFold applies the EqualFold predicate on the "batch_no" field.
+func BatchNoEqualFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEqualFold(FieldBatchNo, v))
+}
+
+// BatchNoContainsFold applies the ContainsFold predicate on the "batch_no" field.
+func BatchNoContainsFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContainsFold(FieldBatchNo, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// QuantityEQ applies the EQ predicate on the "quantity" field.
+func QuantityEQ(v int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldQuantity, v))
+}
+
+// QuantityNEQ applies the NEQ predicate on the "quantity" field.
+func QuantityNEQ(v int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNEQ(FieldQuantity, v))
+}
+
+// QuantityIn applies the In predicate on the "quantity" field.
+func QuantityIn(vs ...int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIn(FieldQuantity, vs...))
+}
+
+// QuantityNotIn applies the NotIn predicate on the "quantity" field.
+func QuantityNotIn(vs ...int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotIn(FieldQuantity, vs...))
+}
+
+// QuantityGT applies the GT predicate on the "quantity" field.
+func QuantityGT(v int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGT(FieldQuantity, v))
+}
+
+// QuantityGTE applies the GTE predicate on the "quantity" field.
+func QuantityGTE(v int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGTE(FieldQuantity, v))
+}
+
+// QuantityLT applies the LT predicate on the "quantity" field.
+func QuantityLT(v int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLT(FieldQuantity, v))
+}
+
+// QuantityLTE applies the LTE predicate on the "quantity" field.
+func QuantityLTE(v int) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLTE(FieldQuantity, v))
+}
+
+// OrderNoEQ applies the EQ predicate on the "order_no" field.
+func OrderNoEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// OrderNoNEQ applies the NEQ predicate on the "order_no" field.
+func OrderNoNEQ(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNEQ(FieldOrderNo, v))
+}
+
+// OrderNoIn applies the In predicate on the "order_no" field.
+func OrderNoIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIn(FieldOrderNo, vs...))
+}
+
+// OrderNoNotIn applies the NotIn predicate on the "order_no" field.
+func OrderNoNotIn(vs ...string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotIn(FieldOrderNo, vs...))
+}
+
+// OrderNoGT applies the GT predicate on the "order_no" field.
+func OrderNoGT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGT(FieldOrderNo, v))
+}
+
+// OrderNoGTE applies the GTE predicate on the "order_no" field.
+func OrderNoGTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGTE(FieldOrderNo, v))
+}
+
+// OrderNoLT applies the LT predicate on the "order_no" field.
+func OrderNoLT(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLT(FieldOrderNo, v))
+}
+
+// OrderNoLTE applies the LTE predicate on the "order_no" field.
+func OrderNoLTE(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLTE(FieldOrderNo, v))
+}
+
+// OrderNoContains applies the Contains predicate on the "order_no" field.
+func OrderNoContains(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContains(FieldOrderNo, v))
+}
+
+// OrderNoHasPrefix applies the HasPrefix predicate on the "order_no" field.
+func OrderNoHasPrefix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasPrefix(FieldOrderNo, v))
+}
+
+// OrderNoHasSuffix applies the HasSuffix predicate on the "order_no" field.
+func OrderNoHasSuffix(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldHasSuffix(FieldOrderNo, v))
+}
+
+// OrderNoIsNil applies the IsNil predicate on the "order_no" field.
+func OrderNoIsNil() predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIsNull(FieldOrderNo))
+}
+
+// OrderNoNotNil applies the NotNil predicate on the "order_no" field.
+func OrderNoNotNil() predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotNull(FieldOrderNo))
+}
+
+// OrderNoEqualFold applies the EqualFold predicate on the "order_no" field.
+func OrderNoEqualFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEqualFold(FieldOrderNo, v))
+}
+
+// OrderNoContainsFold applies the ContainsFold predicate on the "order_no" field.
+func OrderNoContainsFold(v string) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldContainsFold(FieldOrderNo, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.OutboundDetail) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.OutboundDetail) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.OutboundDetail) predicate.OutboundDetail {
+	return predicate.OutboundDetail(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/outboundorder/outboundorder.go b/bj_power_wms/outboundorder/outboundorder.go
new file mode 100644
index 0000000..1f163b2
--- /dev/null
+++ b/bj_power_wms/outboundorder/outboundorder.go
@@ -0,0 +1,270 @@
+// Code generated by ent, DO NOT EDIT.
+
+package outboundorder
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the outboundorder type in the database.
+	Label = "outbound_order"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldOutboundNo holds the string denoting the outbound_no field in the database.
+	FieldOutboundNo = "outbound_no"
+	// FieldOutboundType holds the string denoting the outbound_type field in the database.
+	FieldOutboundType = "outbound_type"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldNeedAgv holds the string denoting the need_agv field in the database.
+	FieldNeedAgv = "need_agv"
+	// FieldOutboundCategory holds the string denoting the outbound_category field in the database.
+	FieldOutboundCategory = "outbound_category"
+	// FieldOwnershipType holds the string denoting the ownership_type field in the database.
+	FieldOwnershipType = "ownership_type"
+	// FieldOwnershipNo holds the string denoting the ownership_no field in the database.
+	FieldOwnershipNo = "ownership_no"
+	// FieldTargetStation holds the string denoting the target_station field in the database.
+	FieldTargetStation = "target_station"
+	// FieldOrderNo holds the string denoting the order_no field in the database.
+	FieldOrderNo = "order_no"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldMaterialName holds the string denoting the material_name field in the database.
+	FieldMaterialName = "material_name"
+	// FieldManageMode holds the string denoting the manage_mode field in the database.
+	FieldManageMode = "manage_mode"
+	// FieldBatchNo holds the string denoting the batch_no field in the database.
+	FieldBatchNo = "batch_no"
+	// FieldZoneCode holds the string denoting the zone_code field in the database.
+	FieldZoneCode = "zone_code"
+	// FieldShelfNo holds the string denoting the shelf_no field in the database.
+	FieldShelfNo = "shelf_no"
+	// FieldLayerNo holds the string denoting the layer_no field in the database.
+	FieldLayerNo = "layer_no"
+	// FieldPositionNo holds the string denoting the position_no field in the database.
+	FieldPositionNo = "position_no"
+	// FieldQuantity holds the string denoting the quantity field in the database.
+	FieldQuantity = "quantity"
+	// FieldOperator holds the string denoting the operator field in the database.
+	FieldOperator = "operator"
+	// FieldReviewer holds the string denoting the reviewer field in the database.
+	FieldReviewer = "reviewer"
+	// FieldTargetDock holds the string denoting the target_dock field in the database.
+	FieldTargetDock = "target_dock"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldBoxNo holds the string denoting the box_no field in the database.
+	FieldBoxNo = "box_no"
+	// FieldBoxSnList holds the string denoting the box_sn_list field in the database.
+	FieldBoxSnList = "box_sn_list"
+	// FieldContractNo holds the string denoting the contract_no field in the database.
+	FieldContractNo = "contract_no"
+	// FieldInspectionNo holds the string denoting the inspection_no field in the database.
+	FieldInspectionNo = "inspection_no"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// Table holds the table name of the outboundorder in the database.
+	Table = "outbound_orders"
+)
+
+// Columns holds all SQL columns for outboundorder fields.
+var Columns = []string{
+	FieldID,
+	FieldOutboundNo,
+	FieldOutboundType,
+	FieldStatus,
+	FieldNeedAgv,
+	FieldOutboundCategory,
+	FieldOwnershipType,
+	FieldOwnershipNo,
+	FieldTargetStation,
+	FieldOrderNo,
+	FieldMaterialCode,
+	FieldMaterialName,
+	FieldManageMode,
+	FieldBatchNo,
+	FieldZoneCode,
+	FieldShelfNo,
+	FieldLayerNo,
+	FieldPositionNo,
+	FieldQuantity,
+	FieldOperator,
+	FieldReviewer,
+	FieldTargetDock,
+	FieldRemark,
+	FieldBoxNo,
+	FieldBoxSnList,
+	FieldContractNo,
+	FieldInspectionNo,
+	FieldCreatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultOutboundType holds the default value on creation for the "outbound_type" field.
+	DefaultOutboundType string
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultNeedAgv holds the default value on creation for the "need_agv" field.
+	DefaultNeedAgv bool
+	// DefaultManageMode holds the default value on creation for the "manage_mode" field.
+	DefaultManageMode int
+	// DefaultQuantity holds the default value on creation for the "quantity" field.
+	DefaultQuantity int
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the OutboundOrder queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByOutboundNo orders the results by the outbound_no field.
+func ByOutboundNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOutboundNo, opts...).ToFunc()
+}
+
+// ByOutboundType orders the results by the outbound_type field.
+func ByOutboundType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOutboundType, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByNeedAgv orders the results by the need_agv field.
+func ByNeedAgv(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldNeedAgv, opts...).ToFunc()
+}
+
+// ByOutboundCategory orders the results by the outbound_category field.
+func ByOutboundCategory(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOutboundCategory, opts...).ToFunc()
+}
+
+// ByOwnershipType orders the results by the ownership_type field.
+func ByOwnershipType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOwnershipType, opts...).ToFunc()
+}
+
+// ByOwnershipNo orders the results by the ownership_no field.
+func ByOwnershipNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOwnershipNo, opts...).ToFunc()
+}
+
+// ByTargetStation orders the results by the target_station field.
+func ByTargetStation(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetStation, opts...).ToFunc()
+}
+
+// ByOrderNo orders the results by the order_no field.
+func ByOrderNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOrderNo, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByMaterialName orders the results by the material_name field.
+func ByMaterialName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialName, opts...).ToFunc()
+}
+
+// ByManageMode orders the results by the manage_mode field.
+func ByManageMode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldManageMode, opts...).ToFunc()
+}
+
+// ByBatchNo orders the results by the batch_no field.
+func ByBatchNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBatchNo, opts...).ToFunc()
+}
+
+// ByZoneCode orders the results by the zone_code field.
+func ByZoneCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldZoneCode, opts...).ToFunc()
+}
+
+// ByShelfNo orders the results by the shelf_no field.
+func ByShelfNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldShelfNo, opts...).ToFunc()
+}
+
+// ByLayerNo orders the results by the layer_no field.
+func ByLayerNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLayerNo, opts...).ToFunc()
+}
+
+// ByPositionNo orders the results by the position_no field.
+func ByPositionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPositionNo, opts...).ToFunc()
+}
+
+// ByQuantity orders the results by the quantity field.
+func ByQuantity(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQuantity, opts...).ToFunc()
+}
+
+// ByOperator orders the results by the operator field.
+func ByOperator(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOperator, opts...).ToFunc()
+}
+
+// ByReviewer orders the results by the reviewer field.
+func ByReviewer(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReviewer, opts...).ToFunc()
+}
+
+// ByTargetDock orders the results by the target_dock field.
+func ByTargetDock(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetDock, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByBoxNo orders the results by the box_no field.
+func ByBoxNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBoxNo, opts...).ToFunc()
+}
+
+// ByBoxSnList orders the results by the box_sn_list field.
+func ByBoxSnList(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBoxSnList, opts...).ToFunc()
+}
+
+// ByContractNo orders the results by the contract_no field.
+func ByContractNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldContractNo, opts...).ToFunc()
+}
+
+// ByInspectionNo orders the results by the inspection_no field.
+func ByInspectionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldInspectionNo, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/outboundorder/where.go b/bj_power_wms/outboundorder/where.go
new file mode 100644
index 0000000..937b8e1
--- /dev/null
+++ b/bj_power_wms/outboundorder/where.go
@@ -0,0 +1,2019 @@
+// Code generated by ent, DO NOT EDIT.
+
+package outboundorder
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldID, id))
+}
+
+// OutboundNo applies equality check predicate on the "outbound_no" field. It's identical to OutboundNoEQ.
+func OutboundNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOutboundNo, v))
+}
+
+// OutboundType applies equality check predicate on the "outbound_type" field. It's identical to OutboundTypeEQ.
+func OutboundType(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOutboundType, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldStatus, v))
+}
+
+// NeedAgv applies equality check predicate on the "need_agv" field. It's identical to NeedAgvEQ.
+func NeedAgv(v bool) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldNeedAgv, v))
+}
+
+// OutboundCategory applies equality check predicate on the "outbound_category" field. It's identical to OutboundCategoryEQ.
+func OutboundCategory(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOutboundCategory, v))
+}
+
+// OwnershipType applies equality check predicate on the "ownership_type" field. It's identical to OwnershipTypeEQ.
+func OwnershipType(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOwnershipType, v))
+}
+
+// OwnershipNo applies equality check predicate on the "ownership_no" field. It's identical to OwnershipNoEQ.
+func OwnershipNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOwnershipNo, v))
+}
+
+// TargetStation applies equality check predicate on the "target_station" field. It's identical to TargetStationEQ.
+func TargetStation(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldTargetStation, v))
+}
+
+// OrderNo applies equality check predicate on the "order_no" field. It's identical to OrderNoEQ.
+func OrderNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialName applies equality check predicate on the "material_name" field. It's identical to MaterialNameEQ.
+func MaterialName(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// ManageMode applies equality check predicate on the "manage_mode" field. It's identical to ManageModeEQ.
+func ManageMode(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldManageMode, v))
+}
+
+// BatchNo applies equality check predicate on the "batch_no" field. It's identical to BatchNoEQ.
+func BatchNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// ZoneCode applies equality check predicate on the "zone_code" field. It's identical to ZoneCodeEQ.
+func ZoneCode(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ShelfNo applies equality check predicate on the "shelf_no" field. It's identical to ShelfNoEQ.
+func ShelfNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// LayerNo applies equality check predicate on the "layer_no" field. It's identical to LayerNoEQ.
+func LayerNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// PositionNo applies equality check predicate on the "position_no" field. It's identical to PositionNoEQ.
+func PositionNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// Quantity applies equality check predicate on the "quantity" field. It's identical to QuantityEQ.
+func Quantity(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldQuantity, v))
+}
+
+// Operator applies equality check predicate on the "operator" field. It's identical to OperatorEQ.
+func Operator(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOperator, v))
+}
+
+// Reviewer applies equality check predicate on the "reviewer" field. It's identical to ReviewerEQ.
+func Reviewer(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldReviewer, v))
+}
+
+// TargetDock applies equality check predicate on the "target_dock" field. It's identical to TargetDockEQ.
+func TargetDock(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldTargetDock, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldRemark, v))
+}
+
+// BoxNo applies equality check predicate on the "box_no" field. It's identical to BoxNoEQ.
+func BoxNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldBoxNo, v))
+}
+
+// BoxSnList applies equality check predicate on the "box_sn_list" field. It's identical to BoxSnListEQ.
+func BoxSnList(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldBoxSnList, v))
+}
+
+// ContractNo applies equality check predicate on the "contract_no" field. It's identical to ContractNoEQ.
+func ContractNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldContractNo, v))
+}
+
+// InspectionNo applies equality check predicate on the "inspection_no" field. It's identical to InspectionNoEQ.
+func InspectionNo(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldInspectionNo, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// OutboundNoEQ applies the EQ predicate on the "outbound_no" field.
+func OutboundNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOutboundNo, v))
+}
+
+// OutboundNoNEQ applies the NEQ predicate on the "outbound_no" field.
+func OutboundNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldOutboundNo, v))
+}
+
+// OutboundNoIn applies the In predicate on the "outbound_no" field.
+func OutboundNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldOutboundNo, vs...))
+}
+
+// OutboundNoNotIn applies the NotIn predicate on the "outbound_no" field.
+func OutboundNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldOutboundNo, vs...))
+}
+
+// OutboundNoGT applies the GT predicate on the "outbound_no" field.
+func OutboundNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldOutboundNo, v))
+}
+
+// OutboundNoGTE applies the GTE predicate on the "outbound_no" field.
+func OutboundNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldOutboundNo, v))
+}
+
+// OutboundNoLT applies the LT predicate on the "outbound_no" field.
+func OutboundNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldOutboundNo, v))
+}
+
+// OutboundNoLTE applies the LTE predicate on the "outbound_no" field.
+func OutboundNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldOutboundNo, v))
+}
+
+// OutboundNoContains applies the Contains predicate on the "outbound_no" field.
+func OutboundNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldOutboundNo, v))
+}
+
+// OutboundNoHasPrefix applies the HasPrefix predicate on the "outbound_no" field.
+func OutboundNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldOutboundNo, v))
+}
+
+// OutboundNoHasSuffix applies the HasSuffix predicate on the "outbound_no" field.
+func OutboundNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldOutboundNo, v))
+}
+
+// OutboundNoEqualFold applies the EqualFold predicate on the "outbound_no" field.
+func OutboundNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldOutboundNo, v))
+}
+
+// OutboundNoContainsFold applies the ContainsFold predicate on the "outbound_no" field.
+func OutboundNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldOutboundNo, v))
+}
+
+// OutboundTypeEQ applies the EQ predicate on the "outbound_type" field.
+func OutboundTypeEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOutboundType, v))
+}
+
+// OutboundTypeNEQ applies the NEQ predicate on the "outbound_type" field.
+func OutboundTypeNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldOutboundType, v))
+}
+
+// OutboundTypeIn applies the In predicate on the "outbound_type" field.
+func OutboundTypeIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldOutboundType, vs...))
+}
+
+// OutboundTypeNotIn applies the NotIn predicate on the "outbound_type" field.
+func OutboundTypeNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldOutboundType, vs...))
+}
+
+// OutboundTypeGT applies the GT predicate on the "outbound_type" field.
+func OutboundTypeGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldOutboundType, v))
+}
+
+// OutboundTypeGTE applies the GTE predicate on the "outbound_type" field.
+func OutboundTypeGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldOutboundType, v))
+}
+
+// OutboundTypeLT applies the LT predicate on the "outbound_type" field.
+func OutboundTypeLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldOutboundType, v))
+}
+
+// OutboundTypeLTE applies the LTE predicate on the "outbound_type" field.
+func OutboundTypeLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldOutboundType, v))
+}
+
+// OutboundTypeContains applies the Contains predicate on the "outbound_type" field.
+func OutboundTypeContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldOutboundType, v))
+}
+
+// OutboundTypeHasPrefix applies the HasPrefix predicate on the "outbound_type" field.
+func OutboundTypeHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldOutboundType, v))
+}
+
+// OutboundTypeHasSuffix applies the HasSuffix predicate on the "outbound_type" field.
+func OutboundTypeHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldOutboundType, v))
+}
+
+// OutboundTypeEqualFold applies the EqualFold predicate on the "outbound_type" field.
+func OutboundTypeEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldOutboundType, v))
+}
+
+// OutboundTypeContainsFold applies the ContainsFold predicate on the "outbound_type" field.
+func OutboundTypeContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldOutboundType, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// NeedAgvEQ applies the EQ predicate on the "need_agv" field.
+func NeedAgvEQ(v bool) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldNeedAgv, v))
+}
+
+// NeedAgvNEQ applies the NEQ predicate on the "need_agv" field.
+func NeedAgvNEQ(v bool) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldNeedAgv, v))
+}
+
+// OutboundCategoryEQ applies the EQ predicate on the "outbound_category" field.
+func OutboundCategoryEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryNEQ applies the NEQ predicate on the "outbound_category" field.
+func OutboundCategoryNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryIn applies the In predicate on the "outbound_category" field.
+func OutboundCategoryIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldOutboundCategory, vs...))
+}
+
+// OutboundCategoryNotIn applies the NotIn predicate on the "outbound_category" field.
+func OutboundCategoryNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldOutboundCategory, vs...))
+}
+
+// OutboundCategoryGT applies the GT predicate on the "outbound_category" field.
+func OutboundCategoryGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryGTE applies the GTE predicate on the "outbound_category" field.
+func OutboundCategoryGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryLT applies the LT predicate on the "outbound_category" field.
+func OutboundCategoryLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryLTE applies the LTE predicate on the "outbound_category" field.
+func OutboundCategoryLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryContains applies the Contains predicate on the "outbound_category" field.
+func OutboundCategoryContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryHasPrefix applies the HasPrefix predicate on the "outbound_category" field.
+func OutboundCategoryHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryHasSuffix applies the HasSuffix predicate on the "outbound_category" field.
+func OutboundCategoryHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryIsNil applies the IsNil predicate on the "outbound_category" field.
+func OutboundCategoryIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldOutboundCategory))
+}
+
+// OutboundCategoryNotNil applies the NotNil predicate on the "outbound_category" field.
+func OutboundCategoryNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldOutboundCategory))
+}
+
+// OutboundCategoryEqualFold applies the EqualFold predicate on the "outbound_category" field.
+func OutboundCategoryEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldOutboundCategory, v))
+}
+
+// OutboundCategoryContainsFold applies the ContainsFold predicate on the "outbound_category" field.
+func OutboundCategoryContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldOutboundCategory, v))
+}
+
+// OwnershipTypeEQ applies the EQ predicate on the "ownership_type" field.
+func OwnershipTypeEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOwnershipType, v))
+}
+
+// OwnershipTypeNEQ applies the NEQ predicate on the "ownership_type" field.
+func OwnershipTypeNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldOwnershipType, v))
+}
+
+// OwnershipTypeIn applies the In predicate on the "ownership_type" field.
+func OwnershipTypeIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldOwnershipType, vs...))
+}
+
+// OwnershipTypeNotIn applies the NotIn predicate on the "ownership_type" field.
+func OwnershipTypeNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldOwnershipType, vs...))
+}
+
+// OwnershipTypeGT applies the GT predicate on the "ownership_type" field.
+func OwnershipTypeGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldOwnershipType, v))
+}
+
+// OwnershipTypeGTE applies the GTE predicate on the "ownership_type" field.
+func OwnershipTypeGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldOwnershipType, v))
+}
+
+// OwnershipTypeLT applies the LT predicate on the "ownership_type" field.
+func OwnershipTypeLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldOwnershipType, v))
+}
+
+// OwnershipTypeLTE applies the LTE predicate on the "ownership_type" field.
+func OwnershipTypeLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldOwnershipType, v))
+}
+
+// OwnershipTypeContains applies the Contains predicate on the "ownership_type" field.
+func OwnershipTypeContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldOwnershipType, v))
+}
+
+// OwnershipTypeHasPrefix applies the HasPrefix predicate on the "ownership_type" field.
+func OwnershipTypeHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldOwnershipType, v))
+}
+
+// OwnershipTypeHasSuffix applies the HasSuffix predicate on the "ownership_type" field.
+func OwnershipTypeHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldOwnershipType, v))
+}
+
+// OwnershipTypeIsNil applies the IsNil predicate on the "ownership_type" field.
+func OwnershipTypeIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldOwnershipType))
+}
+
+// OwnershipTypeNotNil applies the NotNil predicate on the "ownership_type" field.
+func OwnershipTypeNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldOwnershipType))
+}
+
+// OwnershipTypeEqualFold applies the EqualFold predicate on the "ownership_type" field.
+func OwnershipTypeEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldOwnershipType, v))
+}
+
+// OwnershipTypeContainsFold applies the ContainsFold predicate on the "ownership_type" field.
+func OwnershipTypeContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldOwnershipType, v))
+}
+
+// OwnershipNoEQ applies the EQ predicate on the "ownership_no" field.
+func OwnershipNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOwnershipNo, v))
+}
+
+// OwnershipNoNEQ applies the NEQ predicate on the "ownership_no" field.
+func OwnershipNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldOwnershipNo, v))
+}
+
+// OwnershipNoIn applies the In predicate on the "ownership_no" field.
+func OwnershipNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldOwnershipNo, vs...))
+}
+
+// OwnershipNoNotIn applies the NotIn predicate on the "ownership_no" field.
+func OwnershipNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldOwnershipNo, vs...))
+}
+
+// OwnershipNoGT applies the GT predicate on the "ownership_no" field.
+func OwnershipNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldOwnershipNo, v))
+}
+
+// OwnershipNoGTE applies the GTE predicate on the "ownership_no" field.
+func OwnershipNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldOwnershipNo, v))
+}
+
+// OwnershipNoLT applies the LT predicate on the "ownership_no" field.
+func OwnershipNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldOwnershipNo, v))
+}
+
+// OwnershipNoLTE applies the LTE predicate on the "ownership_no" field.
+func OwnershipNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldOwnershipNo, v))
+}
+
+// OwnershipNoContains applies the Contains predicate on the "ownership_no" field.
+func OwnershipNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldOwnershipNo, v))
+}
+
+// OwnershipNoHasPrefix applies the HasPrefix predicate on the "ownership_no" field.
+func OwnershipNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldOwnershipNo, v))
+}
+
+// OwnershipNoHasSuffix applies the HasSuffix predicate on the "ownership_no" field.
+func OwnershipNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldOwnershipNo, v))
+}
+
+// OwnershipNoIsNil applies the IsNil predicate on the "ownership_no" field.
+func OwnershipNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldOwnershipNo))
+}
+
+// OwnershipNoNotNil applies the NotNil predicate on the "ownership_no" field.
+func OwnershipNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldOwnershipNo))
+}
+
+// OwnershipNoEqualFold applies the EqualFold predicate on the "ownership_no" field.
+func OwnershipNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldOwnershipNo, v))
+}
+
+// OwnershipNoContainsFold applies the ContainsFold predicate on the "ownership_no" field.
+func OwnershipNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldOwnershipNo, v))
+}
+
+// TargetStationEQ applies the EQ predicate on the "target_station" field.
+func TargetStationEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldTargetStation, v))
+}
+
+// TargetStationNEQ applies the NEQ predicate on the "target_station" field.
+func TargetStationNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldTargetStation, v))
+}
+
+// TargetStationIn applies the In predicate on the "target_station" field.
+func TargetStationIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldTargetStation, vs...))
+}
+
+// TargetStationNotIn applies the NotIn predicate on the "target_station" field.
+func TargetStationNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldTargetStation, vs...))
+}
+
+// TargetStationGT applies the GT predicate on the "target_station" field.
+func TargetStationGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldTargetStation, v))
+}
+
+// TargetStationGTE applies the GTE predicate on the "target_station" field.
+func TargetStationGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldTargetStation, v))
+}
+
+// TargetStationLT applies the LT predicate on the "target_station" field.
+func TargetStationLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldTargetStation, v))
+}
+
+// TargetStationLTE applies the LTE predicate on the "target_station" field.
+func TargetStationLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldTargetStation, v))
+}
+
+// TargetStationContains applies the Contains predicate on the "target_station" field.
+func TargetStationContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldTargetStation, v))
+}
+
+// TargetStationHasPrefix applies the HasPrefix predicate on the "target_station" field.
+func TargetStationHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldTargetStation, v))
+}
+
+// TargetStationHasSuffix applies the HasSuffix predicate on the "target_station" field.
+func TargetStationHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldTargetStation, v))
+}
+
+// TargetStationIsNil applies the IsNil predicate on the "target_station" field.
+func TargetStationIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldTargetStation))
+}
+
+// TargetStationNotNil applies the NotNil predicate on the "target_station" field.
+func TargetStationNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldTargetStation))
+}
+
+// TargetStationEqualFold applies the EqualFold predicate on the "target_station" field.
+func TargetStationEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldTargetStation, v))
+}
+
+// TargetStationContainsFold applies the ContainsFold predicate on the "target_station" field.
+func TargetStationContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldTargetStation, v))
+}
+
+// OrderNoEQ applies the EQ predicate on the "order_no" field.
+func OrderNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// OrderNoNEQ applies the NEQ predicate on the "order_no" field.
+func OrderNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldOrderNo, v))
+}
+
+// OrderNoIn applies the In predicate on the "order_no" field.
+func OrderNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldOrderNo, vs...))
+}
+
+// OrderNoNotIn applies the NotIn predicate on the "order_no" field.
+func OrderNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldOrderNo, vs...))
+}
+
+// OrderNoGT applies the GT predicate on the "order_no" field.
+func OrderNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldOrderNo, v))
+}
+
+// OrderNoGTE applies the GTE predicate on the "order_no" field.
+func OrderNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldOrderNo, v))
+}
+
+// OrderNoLT applies the LT predicate on the "order_no" field.
+func OrderNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldOrderNo, v))
+}
+
+// OrderNoLTE applies the LTE predicate on the "order_no" field.
+func OrderNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldOrderNo, v))
+}
+
+// OrderNoContains applies the Contains predicate on the "order_no" field.
+func OrderNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldOrderNo, v))
+}
+
+// OrderNoHasPrefix applies the HasPrefix predicate on the "order_no" field.
+func OrderNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldOrderNo, v))
+}
+
+// OrderNoHasSuffix applies the HasSuffix predicate on the "order_no" field.
+func OrderNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldOrderNo, v))
+}
+
+// OrderNoIsNil applies the IsNil predicate on the "order_no" field.
+func OrderNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldOrderNo))
+}
+
+// OrderNoNotNil applies the NotNil predicate on the "order_no" field.
+func OrderNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldOrderNo))
+}
+
+// OrderNoEqualFold applies the EqualFold predicate on the "order_no" field.
+func OrderNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldOrderNo, v))
+}
+
+// OrderNoContainsFold applies the ContainsFold predicate on the "order_no" field.
+func OrderNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldOrderNo, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// MaterialNameEQ applies the EQ predicate on the "material_name" field.
+func MaterialNameEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// MaterialNameNEQ applies the NEQ predicate on the "material_name" field.
+func MaterialNameNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldMaterialName, v))
+}
+
+// MaterialNameIn applies the In predicate on the "material_name" field.
+func MaterialNameIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameNotIn applies the NotIn predicate on the "material_name" field.
+func MaterialNameNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameGT applies the GT predicate on the "material_name" field.
+func MaterialNameGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldMaterialName, v))
+}
+
+// MaterialNameGTE applies the GTE predicate on the "material_name" field.
+func MaterialNameGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldMaterialName, v))
+}
+
+// MaterialNameLT applies the LT predicate on the "material_name" field.
+func MaterialNameLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldMaterialName, v))
+}
+
+// MaterialNameLTE applies the LTE predicate on the "material_name" field.
+func MaterialNameLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldMaterialName, v))
+}
+
+// MaterialNameContains applies the Contains predicate on the "material_name" field.
+func MaterialNameContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldMaterialName, v))
+}
+
+// MaterialNameHasPrefix applies the HasPrefix predicate on the "material_name" field.
+func MaterialNameHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldMaterialName, v))
+}
+
+// MaterialNameHasSuffix applies the HasSuffix predicate on the "material_name" field.
+func MaterialNameHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldMaterialName, v))
+}
+
+// MaterialNameIsNil applies the IsNil predicate on the "material_name" field.
+func MaterialNameIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldMaterialName))
+}
+
+// MaterialNameNotNil applies the NotNil predicate on the "material_name" field.
+func MaterialNameNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldMaterialName))
+}
+
+// MaterialNameEqualFold applies the EqualFold predicate on the "material_name" field.
+func MaterialNameEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldMaterialName, v))
+}
+
+// MaterialNameContainsFold applies the ContainsFold predicate on the "material_name" field.
+func MaterialNameContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldMaterialName, v))
+}
+
+// ManageModeEQ applies the EQ predicate on the "manage_mode" field.
+func ManageModeEQ(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldManageMode, v))
+}
+
+// ManageModeNEQ applies the NEQ predicate on the "manage_mode" field.
+func ManageModeNEQ(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldManageMode, v))
+}
+
+// ManageModeIn applies the In predicate on the "manage_mode" field.
+func ManageModeIn(vs ...int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldManageMode, vs...))
+}
+
+// ManageModeNotIn applies the NotIn predicate on the "manage_mode" field.
+func ManageModeNotIn(vs ...int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldManageMode, vs...))
+}
+
+// ManageModeGT applies the GT predicate on the "manage_mode" field.
+func ManageModeGT(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldManageMode, v))
+}
+
+// ManageModeGTE applies the GTE predicate on the "manage_mode" field.
+func ManageModeGTE(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldManageMode, v))
+}
+
+// ManageModeLT applies the LT predicate on the "manage_mode" field.
+func ManageModeLT(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldManageMode, v))
+}
+
+// ManageModeLTE applies the LTE predicate on the "manage_mode" field.
+func ManageModeLTE(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldManageMode, v))
+}
+
+// BatchNoEQ applies the EQ predicate on the "batch_no" field.
+func BatchNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldBatchNo, v))
+}
+
+// BatchNoNEQ applies the NEQ predicate on the "batch_no" field.
+func BatchNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldBatchNo, v))
+}
+
+// BatchNoIn applies the In predicate on the "batch_no" field.
+func BatchNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldBatchNo, vs...))
+}
+
+// BatchNoNotIn applies the NotIn predicate on the "batch_no" field.
+func BatchNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldBatchNo, vs...))
+}
+
+// BatchNoGT applies the GT predicate on the "batch_no" field.
+func BatchNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldBatchNo, v))
+}
+
+// BatchNoGTE applies the GTE predicate on the "batch_no" field.
+func BatchNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldBatchNo, v))
+}
+
+// BatchNoLT applies the LT predicate on the "batch_no" field.
+func BatchNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldBatchNo, v))
+}
+
+// BatchNoLTE applies the LTE predicate on the "batch_no" field.
+func BatchNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldBatchNo, v))
+}
+
+// BatchNoContains applies the Contains predicate on the "batch_no" field.
+func BatchNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldBatchNo, v))
+}
+
+// BatchNoHasPrefix applies the HasPrefix predicate on the "batch_no" field.
+func BatchNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldBatchNo, v))
+}
+
+// BatchNoHasSuffix applies the HasSuffix predicate on the "batch_no" field.
+func BatchNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldBatchNo, v))
+}
+
+// BatchNoIsNil applies the IsNil predicate on the "batch_no" field.
+func BatchNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldBatchNo))
+}
+
+// BatchNoNotNil applies the NotNil predicate on the "batch_no" field.
+func BatchNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldBatchNo))
+}
+
+// BatchNoEqualFold applies the EqualFold predicate on the "batch_no" field.
+func BatchNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldBatchNo, v))
+}
+
+// BatchNoContainsFold applies the ContainsFold predicate on the "batch_no" field.
+func BatchNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldBatchNo, v))
+}
+
+// ZoneCodeEQ applies the EQ predicate on the "zone_code" field.
+func ZoneCodeEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeNEQ applies the NEQ predicate on the "zone_code" field.
+func ZoneCodeNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeIn applies the In predicate on the "zone_code" field.
+func ZoneCodeIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeNotIn applies the NotIn predicate on the "zone_code" field.
+func ZoneCodeNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeGT applies the GT predicate on the "zone_code" field.
+func ZoneCodeGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldZoneCode, v))
+}
+
+// ZoneCodeGTE applies the GTE predicate on the "zone_code" field.
+func ZoneCodeGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldZoneCode, v))
+}
+
+// ZoneCodeLT applies the LT predicate on the "zone_code" field.
+func ZoneCodeLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldZoneCode, v))
+}
+
+// ZoneCodeLTE applies the LTE predicate on the "zone_code" field.
+func ZoneCodeLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldZoneCode, v))
+}
+
+// ZoneCodeContains applies the Contains predicate on the "zone_code" field.
+func ZoneCodeContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldZoneCode, v))
+}
+
+// ZoneCodeHasPrefix applies the HasPrefix predicate on the "zone_code" field.
+func ZoneCodeHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldZoneCode, v))
+}
+
+// ZoneCodeHasSuffix applies the HasSuffix predicate on the "zone_code" field.
+func ZoneCodeHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldZoneCode, v))
+}
+
+// ZoneCodeIsNil applies the IsNil predicate on the "zone_code" field.
+func ZoneCodeIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldZoneCode))
+}
+
+// ZoneCodeNotNil applies the NotNil predicate on the "zone_code" field.
+func ZoneCodeNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldZoneCode))
+}
+
+// ZoneCodeEqualFold applies the EqualFold predicate on the "zone_code" field.
+func ZoneCodeEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldZoneCode, v))
+}
+
+// ZoneCodeContainsFold applies the ContainsFold predicate on the "zone_code" field.
+func ZoneCodeContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldZoneCode, v))
+}
+
+// ShelfNoEQ applies the EQ predicate on the "shelf_no" field.
+func ShelfNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// ShelfNoNEQ applies the NEQ predicate on the "shelf_no" field.
+func ShelfNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldShelfNo, v))
+}
+
+// ShelfNoIn applies the In predicate on the "shelf_no" field.
+func ShelfNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoNotIn applies the NotIn predicate on the "shelf_no" field.
+func ShelfNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoGT applies the GT predicate on the "shelf_no" field.
+func ShelfNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldShelfNo, v))
+}
+
+// ShelfNoGTE applies the GTE predicate on the "shelf_no" field.
+func ShelfNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldShelfNo, v))
+}
+
+// ShelfNoLT applies the LT predicate on the "shelf_no" field.
+func ShelfNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldShelfNo, v))
+}
+
+// ShelfNoLTE applies the LTE predicate on the "shelf_no" field.
+func ShelfNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldShelfNo, v))
+}
+
+// ShelfNoContains applies the Contains predicate on the "shelf_no" field.
+func ShelfNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldShelfNo, v))
+}
+
+// ShelfNoHasPrefix applies the HasPrefix predicate on the "shelf_no" field.
+func ShelfNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldShelfNo, v))
+}
+
+// ShelfNoHasSuffix applies the HasSuffix predicate on the "shelf_no" field.
+func ShelfNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldShelfNo, v))
+}
+
+// ShelfNoIsNil applies the IsNil predicate on the "shelf_no" field.
+func ShelfNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldShelfNo))
+}
+
+// ShelfNoNotNil applies the NotNil predicate on the "shelf_no" field.
+func ShelfNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldShelfNo))
+}
+
+// ShelfNoEqualFold applies the EqualFold predicate on the "shelf_no" field.
+func ShelfNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldShelfNo, v))
+}
+
+// ShelfNoContainsFold applies the ContainsFold predicate on the "shelf_no" field.
+func ShelfNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldShelfNo, v))
+}
+
+// LayerNoEQ applies the EQ predicate on the "layer_no" field.
+func LayerNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// LayerNoNEQ applies the NEQ predicate on the "layer_no" field.
+func LayerNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldLayerNo, v))
+}
+
+// LayerNoIn applies the In predicate on the "layer_no" field.
+func LayerNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldLayerNo, vs...))
+}
+
+// LayerNoNotIn applies the NotIn predicate on the "layer_no" field.
+func LayerNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldLayerNo, vs...))
+}
+
+// LayerNoGT applies the GT predicate on the "layer_no" field.
+func LayerNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldLayerNo, v))
+}
+
+// LayerNoGTE applies the GTE predicate on the "layer_no" field.
+func LayerNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldLayerNo, v))
+}
+
+// LayerNoLT applies the LT predicate on the "layer_no" field.
+func LayerNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldLayerNo, v))
+}
+
+// LayerNoLTE applies the LTE predicate on the "layer_no" field.
+func LayerNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldLayerNo, v))
+}
+
+// LayerNoContains applies the Contains predicate on the "layer_no" field.
+func LayerNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldLayerNo, v))
+}
+
+// LayerNoHasPrefix applies the HasPrefix predicate on the "layer_no" field.
+func LayerNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldLayerNo, v))
+}
+
+// LayerNoHasSuffix applies the HasSuffix predicate on the "layer_no" field.
+func LayerNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldLayerNo, v))
+}
+
+// LayerNoIsNil applies the IsNil predicate on the "layer_no" field.
+func LayerNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldLayerNo))
+}
+
+// LayerNoNotNil applies the NotNil predicate on the "layer_no" field.
+func LayerNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldLayerNo))
+}
+
+// LayerNoEqualFold applies the EqualFold predicate on the "layer_no" field.
+func LayerNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldLayerNo, v))
+}
+
+// LayerNoContainsFold applies the ContainsFold predicate on the "layer_no" field.
+func LayerNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldLayerNo, v))
+}
+
+// PositionNoEQ applies the EQ predicate on the "position_no" field.
+func PositionNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// PositionNoNEQ applies the NEQ predicate on the "position_no" field.
+func PositionNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldPositionNo, v))
+}
+
+// PositionNoIn applies the In predicate on the "position_no" field.
+func PositionNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldPositionNo, vs...))
+}
+
+// PositionNoNotIn applies the NotIn predicate on the "position_no" field.
+func PositionNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldPositionNo, vs...))
+}
+
+// PositionNoGT applies the GT predicate on the "position_no" field.
+func PositionNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldPositionNo, v))
+}
+
+// PositionNoGTE applies the GTE predicate on the "position_no" field.
+func PositionNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldPositionNo, v))
+}
+
+// PositionNoLT applies the LT predicate on the "position_no" field.
+func PositionNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldPositionNo, v))
+}
+
+// PositionNoLTE applies the LTE predicate on the "position_no" field.
+func PositionNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldPositionNo, v))
+}
+
+// PositionNoContains applies the Contains predicate on the "position_no" field.
+func PositionNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldPositionNo, v))
+}
+
+// PositionNoHasPrefix applies the HasPrefix predicate on the "position_no" field.
+func PositionNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldPositionNo, v))
+}
+
+// PositionNoHasSuffix applies the HasSuffix predicate on the "position_no" field.
+func PositionNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldPositionNo, v))
+}
+
+// PositionNoIsNil applies the IsNil predicate on the "position_no" field.
+func PositionNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldPositionNo))
+}
+
+// PositionNoNotNil applies the NotNil predicate on the "position_no" field.
+func PositionNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldPositionNo))
+}
+
+// PositionNoEqualFold applies the EqualFold predicate on the "position_no" field.
+func PositionNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldPositionNo, v))
+}
+
+// PositionNoContainsFold applies the ContainsFold predicate on the "position_no" field.
+func PositionNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldPositionNo, v))
+}
+
+// QuantityEQ applies the EQ predicate on the "quantity" field.
+func QuantityEQ(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldQuantity, v))
+}
+
+// QuantityNEQ applies the NEQ predicate on the "quantity" field.
+func QuantityNEQ(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldQuantity, v))
+}
+
+// QuantityIn applies the In predicate on the "quantity" field.
+func QuantityIn(vs ...int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldQuantity, vs...))
+}
+
+// QuantityNotIn applies the NotIn predicate on the "quantity" field.
+func QuantityNotIn(vs ...int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldQuantity, vs...))
+}
+
+// QuantityGT applies the GT predicate on the "quantity" field.
+func QuantityGT(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldQuantity, v))
+}
+
+// QuantityGTE applies the GTE predicate on the "quantity" field.
+func QuantityGTE(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldQuantity, v))
+}
+
+// QuantityLT applies the LT predicate on the "quantity" field.
+func QuantityLT(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldQuantity, v))
+}
+
+// QuantityLTE applies the LTE predicate on the "quantity" field.
+func QuantityLTE(v int) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldQuantity, v))
+}
+
+// OperatorEQ applies the EQ predicate on the "operator" field.
+func OperatorEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldOperator, v))
+}
+
+// OperatorNEQ applies the NEQ predicate on the "operator" field.
+func OperatorNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldOperator, v))
+}
+
+// OperatorIn applies the In predicate on the "operator" field.
+func OperatorIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldOperator, vs...))
+}
+
+// OperatorNotIn applies the NotIn predicate on the "operator" field.
+func OperatorNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldOperator, vs...))
+}
+
+// OperatorGT applies the GT predicate on the "operator" field.
+func OperatorGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldOperator, v))
+}
+
+// OperatorGTE applies the GTE predicate on the "operator" field.
+func OperatorGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldOperator, v))
+}
+
+// OperatorLT applies the LT predicate on the "operator" field.
+func OperatorLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldOperator, v))
+}
+
+// OperatorLTE applies the LTE predicate on the "operator" field.
+func OperatorLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldOperator, v))
+}
+
+// OperatorContains applies the Contains predicate on the "operator" field.
+func OperatorContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldOperator, v))
+}
+
+// OperatorHasPrefix applies the HasPrefix predicate on the "operator" field.
+func OperatorHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldOperator, v))
+}
+
+// OperatorHasSuffix applies the HasSuffix predicate on the "operator" field.
+func OperatorHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldOperator, v))
+}
+
+// OperatorIsNil applies the IsNil predicate on the "operator" field.
+func OperatorIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldOperator))
+}
+
+// OperatorNotNil applies the NotNil predicate on the "operator" field.
+func OperatorNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldOperator))
+}
+
+// OperatorEqualFold applies the EqualFold predicate on the "operator" field.
+func OperatorEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldOperator, v))
+}
+
+// OperatorContainsFold applies the ContainsFold predicate on the "operator" field.
+func OperatorContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldOperator, v))
+}
+
+// ReviewerEQ applies the EQ predicate on the "reviewer" field.
+func ReviewerEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldReviewer, v))
+}
+
+// ReviewerNEQ applies the NEQ predicate on the "reviewer" field.
+func ReviewerNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldReviewer, v))
+}
+
+// ReviewerIn applies the In predicate on the "reviewer" field.
+func ReviewerIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldReviewer, vs...))
+}
+
+// ReviewerNotIn applies the NotIn predicate on the "reviewer" field.
+func ReviewerNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldReviewer, vs...))
+}
+
+// ReviewerGT applies the GT predicate on the "reviewer" field.
+func ReviewerGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldReviewer, v))
+}
+
+// ReviewerGTE applies the GTE predicate on the "reviewer" field.
+func ReviewerGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldReviewer, v))
+}
+
+// ReviewerLT applies the LT predicate on the "reviewer" field.
+func ReviewerLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldReviewer, v))
+}
+
+// ReviewerLTE applies the LTE predicate on the "reviewer" field.
+func ReviewerLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldReviewer, v))
+}
+
+// ReviewerContains applies the Contains predicate on the "reviewer" field.
+func ReviewerContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldReviewer, v))
+}
+
+// ReviewerHasPrefix applies the HasPrefix predicate on the "reviewer" field.
+func ReviewerHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldReviewer, v))
+}
+
+// ReviewerHasSuffix applies the HasSuffix predicate on the "reviewer" field.
+func ReviewerHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldReviewer, v))
+}
+
+// ReviewerIsNil applies the IsNil predicate on the "reviewer" field.
+func ReviewerIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldReviewer))
+}
+
+// ReviewerNotNil applies the NotNil predicate on the "reviewer" field.
+func ReviewerNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldReviewer))
+}
+
+// ReviewerEqualFold applies the EqualFold predicate on the "reviewer" field.
+func ReviewerEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldReviewer, v))
+}
+
+// ReviewerContainsFold applies the ContainsFold predicate on the "reviewer" field.
+func ReviewerContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldReviewer, v))
+}
+
+// TargetDockEQ applies the EQ predicate on the "target_dock" field.
+func TargetDockEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldTargetDock, v))
+}
+
+// TargetDockNEQ applies the NEQ predicate on the "target_dock" field.
+func TargetDockNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldTargetDock, v))
+}
+
+// TargetDockIn applies the In predicate on the "target_dock" field.
+func TargetDockIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldTargetDock, vs...))
+}
+
+// TargetDockNotIn applies the NotIn predicate on the "target_dock" field.
+func TargetDockNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldTargetDock, vs...))
+}
+
+// TargetDockGT applies the GT predicate on the "target_dock" field.
+func TargetDockGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldTargetDock, v))
+}
+
+// TargetDockGTE applies the GTE predicate on the "target_dock" field.
+func TargetDockGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldTargetDock, v))
+}
+
+// TargetDockLT applies the LT predicate on the "target_dock" field.
+func TargetDockLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldTargetDock, v))
+}
+
+// TargetDockLTE applies the LTE predicate on the "target_dock" field.
+func TargetDockLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldTargetDock, v))
+}
+
+// TargetDockContains applies the Contains predicate on the "target_dock" field.
+func TargetDockContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldTargetDock, v))
+}
+
+// TargetDockHasPrefix applies the HasPrefix predicate on the "target_dock" field.
+func TargetDockHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldTargetDock, v))
+}
+
+// TargetDockHasSuffix applies the HasSuffix predicate on the "target_dock" field.
+func TargetDockHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldTargetDock, v))
+}
+
+// TargetDockIsNil applies the IsNil predicate on the "target_dock" field.
+func TargetDockIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldTargetDock))
+}
+
+// TargetDockNotNil applies the NotNil predicate on the "target_dock" field.
+func TargetDockNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldTargetDock))
+}
+
+// TargetDockEqualFold applies the EqualFold predicate on the "target_dock" field.
+func TargetDockEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldTargetDock, v))
+}
+
+// TargetDockContainsFold applies the ContainsFold predicate on the "target_dock" field.
+func TargetDockContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldTargetDock, v))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// BoxNoEQ applies the EQ predicate on the "box_no" field.
+func BoxNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldBoxNo, v))
+}
+
+// BoxNoNEQ applies the NEQ predicate on the "box_no" field.
+func BoxNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldBoxNo, v))
+}
+
+// BoxNoIn applies the In predicate on the "box_no" field.
+func BoxNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldBoxNo, vs...))
+}
+
+// BoxNoNotIn applies the NotIn predicate on the "box_no" field.
+func BoxNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldBoxNo, vs...))
+}
+
+// BoxNoGT applies the GT predicate on the "box_no" field.
+func BoxNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldBoxNo, v))
+}
+
+// BoxNoGTE applies the GTE predicate on the "box_no" field.
+func BoxNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldBoxNo, v))
+}
+
+// BoxNoLT applies the LT predicate on the "box_no" field.
+func BoxNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldBoxNo, v))
+}
+
+// BoxNoLTE applies the LTE predicate on the "box_no" field.
+func BoxNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldBoxNo, v))
+}
+
+// BoxNoContains applies the Contains predicate on the "box_no" field.
+func BoxNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldBoxNo, v))
+}
+
+// BoxNoHasPrefix applies the HasPrefix predicate on the "box_no" field.
+func BoxNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldBoxNo, v))
+}
+
+// BoxNoHasSuffix applies the HasSuffix predicate on the "box_no" field.
+func BoxNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldBoxNo, v))
+}
+
+// BoxNoIsNil applies the IsNil predicate on the "box_no" field.
+func BoxNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldBoxNo))
+}
+
+// BoxNoNotNil applies the NotNil predicate on the "box_no" field.
+func BoxNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldBoxNo))
+}
+
+// BoxNoEqualFold applies the EqualFold predicate on the "box_no" field.
+func BoxNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldBoxNo, v))
+}
+
+// BoxNoContainsFold applies the ContainsFold predicate on the "box_no" field.
+func BoxNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldBoxNo, v))
+}
+
+// BoxSnListEQ applies the EQ predicate on the "box_sn_list" field.
+func BoxSnListEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldBoxSnList, v))
+}
+
+// BoxSnListNEQ applies the NEQ predicate on the "box_sn_list" field.
+func BoxSnListNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldBoxSnList, v))
+}
+
+// BoxSnListIn applies the In predicate on the "box_sn_list" field.
+func BoxSnListIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldBoxSnList, vs...))
+}
+
+// BoxSnListNotIn applies the NotIn predicate on the "box_sn_list" field.
+func BoxSnListNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldBoxSnList, vs...))
+}
+
+// BoxSnListGT applies the GT predicate on the "box_sn_list" field.
+func BoxSnListGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldBoxSnList, v))
+}
+
+// BoxSnListGTE applies the GTE predicate on the "box_sn_list" field.
+func BoxSnListGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldBoxSnList, v))
+}
+
+// BoxSnListLT applies the LT predicate on the "box_sn_list" field.
+func BoxSnListLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldBoxSnList, v))
+}
+
+// BoxSnListLTE applies the LTE predicate on the "box_sn_list" field.
+func BoxSnListLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldBoxSnList, v))
+}
+
+// BoxSnListContains applies the Contains predicate on the "box_sn_list" field.
+func BoxSnListContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldBoxSnList, v))
+}
+
+// BoxSnListHasPrefix applies the HasPrefix predicate on the "box_sn_list" field.
+func BoxSnListHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldBoxSnList, v))
+}
+
+// BoxSnListHasSuffix applies the HasSuffix predicate on the "box_sn_list" field.
+func BoxSnListHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldBoxSnList, v))
+}
+
+// BoxSnListIsNil applies the IsNil predicate on the "box_sn_list" field.
+func BoxSnListIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldBoxSnList))
+}
+
+// BoxSnListNotNil applies the NotNil predicate on the "box_sn_list" field.
+func BoxSnListNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldBoxSnList))
+}
+
+// BoxSnListEqualFold applies the EqualFold predicate on the "box_sn_list" field.
+func BoxSnListEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldBoxSnList, v))
+}
+
+// BoxSnListContainsFold applies the ContainsFold predicate on the "box_sn_list" field.
+func BoxSnListContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldBoxSnList, v))
+}
+
+// ContractNoEQ applies the EQ predicate on the "contract_no" field.
+func ContractNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldContractNo, v))
+}
+
+// ContractNoNEQ applies the NEQ predicate on the "contract_no" field.
+func ContractNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldContractNo, v))
+}
+
+// ContractNoIn applies the In predicate on the "contract_no" field.
+func ContractNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldContractNo, vs...))
+}
+
+// ContractNoNotIn applies the NotIn predicate on the "contract_no" field.
+func ContractNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldContractNo, vs...))
+}
+
+// ContractNoGT applies the GT predicate on the "contract_no" field.
+func ContractNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldContractNo, v))
+}
+
+// ContractNoGTE applies the GTE predicate on the "contract_no" field.
+func ContractNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldContractNo, v))
+}
+
+// ContractNoLT applies the LT predicate on the "contract_no" field.
+func ContractNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldContractNo, v))
+}
+
+// ContractNoLTE applies the LTE predicate on the "contract_no" field.
+func ContractNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldContractNo, v))
+}
+
+// ContractNoContains applies the Contains predicate on the "contract_no" field.
+func ContractNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldContractNo, v))
+}
+
+// ContractNoHasPrefix applies the HasPrefix predicate on the "contract_no" field.
+func ContractNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldContractNo, v))
+}
+
+// ContractNoHasSuffix applies the HasSuffix predicate on the "contract_no" field.
+func ContractNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldContractNo, v))
+}
+
+// ContractNoIsNil applies the IsNil predicate on the "contract_no" field.
+func ContractNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldContractNo))
+}
+
+// ContractNoNotNil applies the NotNil predicate on the "contract_no" field.
+func ContractNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldContractNo))
+}
+
+// ContractNoEqualFold applies the EqualFold predicate on the "contract_no" field.
+func ContractNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldContractNo, v))
+}
+
+// ContractNoContainsFold applies the ContainsFold predicate on the "contract_no" field.
+func ContractNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldContractNo, v))
+}
+
+// InspectionNoEQ applies the EQ predicate on the "inspection_no" field.
+func InspectionNoEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldInspectionNo, v))
+}
+
+// InspectionNoNEQ applies the NEQ predicate on the "inspection_no" field.
+func InspectionNoNEQ(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldInspectionNo, v))
+}
+
+// InspectionNoIn applies the In predicate on the "inspection_no" field.
+func InspectionNoIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldInspectionNo, vs...))
+}
+
+// InspectionNoNotIn applies the NotIn predicate on the "inspection_no" field.
+func InspectionNoNotIn(vs ...string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldInspectionNo, vs...))
+}
+
+// InspectionNoGT applies the GT predicate on the "inspection_no" field.
+func InspectionNoGT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldInspectionNo, v))
+}
+
+// InspectionNoGTE applies the GTE predicate on the "inspection_no" field.
+func InspectionNoGTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldInspectionNo, v))
+}
+
+// InspectionNoLT applies the LT predicate on the "inspection_no" field.
+func InspectionNoLT(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldInspectionNo, v))
+}
+
+// InspectionNoLTE applies the LTE predicate on the "inspection_no" field.
+func InspectionNoLTE(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldInspectionNo, v))
+}
+
+// InspectionNoContains applies the Contains predicate on the "inspection_no" field.
+func InspectionNoContains(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContains(FieldInspectionNo, v))
+}
+
+// InspectionNoHasPrefix applies the HasPrefix predicate on the "inspection_no" field.
+func InspectionNoHasPrefix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasPrefix(FieldInspectionNo, v))
+}
+
+// InspectionNoHasSuffix applies the HasSuffix predicate on the "inspection_no" field.
+func InspectionNoHasSuffix(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldHasSuffix(FieldInspectionNo, v))
+}
+
+// InspectionNoIsNil applies the IsNil predicate on the "inspection_no" field.
+func InspectionNoIsNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIsNull(FieldInspectionNo))
+}
+
+// InspectionNoNotNil applies the NotNil predicate on the "inspection_no" field.
+func InspectionNoNotNil() predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotNull(FieldInspectionNo))
+}
+
+// InspectionNoEqualFold applies the EqualFold predicate on the "inspection_no" field.
+func InspectionNoEqualFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEqualFold(FieldInspectionNo, v))
+}
+
+// InspectionNoContainsFold applies the ContainsFold predicate on the "inspection_no" field.
+func InspectionNoContainsFold(v string) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldContainsFold(FieldInspectionNo, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.OutboundOrder) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.OutboundOrder) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.OutboundOrder) predicate.OutboundOrder {
+	return predicate.OutboundOrder(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/permission/permission.go b/bj_power_wms/permission/permission.go
new file mode 100644
index 0000000..dfab14e
--- /dev/null
+++ b/bj_power_wms/permission/permission.go
@@ -0,0 +1,152 @@
+// Code generated by ent, DO NOT EDIT.
+
+package permission
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the permission type in the database.
+	Label = "permission"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldCode holds the string denoting the code field in the database.
+	FieldCode = "code"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldType holds the string denoting the type field in the database.
+	FieldType = "type"
+	// FieldParentCode holds the string denoting the parent_code field in the database.
+	FieldParentCode = "parent_code"
+	// FieldPath holds the string denoting the path field in the database.
+	FieldPath = "path"
+	// FieldIcon holds the string denoting the icon field in the database.
+	FieldIcon = "icon"
+	// FieldSort holds the string denoting the sort field in the database.
+	FieldSort = "sort"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the permission in the database.
+	Table = "permissions"
+)
+
+// Columns holds all SQL columns for permission fields.
+var Columns = []string{
+	FieldID,
+	FieldCode,
+	FieldName,
+	FieldType,
+	FieldParentCode,
+	FieldPath,
+	FieldIcon,
+	FieldSort,
+	FieldRemark,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// CodeValidator is a validator for the "code" field. It is called by the builders before save.
+	CodeValidator func(string) error
+	// NameValidator is a validator for the "name" field. It is called by the builders before save.
+	NameValidator func(string) error
+	// DefaultType holds the default value on creation for the "type" field.
+	DefaultType string
+	// TypeValidator is a validator for the "type" field. It is called by the builders before save.
+	TypeValidator func(string) error
+	// DefaultParentCode holds the default value on creation for the "parent_code" field.
+	DefaultParentCode string
+	// ParentCodeValidator is a validator for the "parent_code" field. It is called by the builders before save.
+	ParentCodeValidator func(string) error
+	// DefaultPath holds the default value on creation for the "path" field.
+	DefaultPath string
+	// PathValidator is a validator for the "path" field. It is called by the builders before save.
+	PathValidator func(string) error
+	// DefaultIcon holds the default value on creation for the "icon" field.
+	DefaultIcon string
+	// IconValidator is a validator for the "icon" field. It is called by the builders before save.
+	IconValidator func(string) error
+	// DefaultSort holds the default value on creation for the "sort" field.
+	DefaultSort int
+	// DefaultRemark holds the default value on creation for the "remark" field.
+	DefaultRemark string
+	// RemarkValidator is a validator for the "remark" field. It is called by the builders before save.
+	RemarkValidator func(string) error
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the Permission queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByCode orders the results by the code field.
+func ByCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCode, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByType orders the results by the type field.
+func ByType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldType, opts...).ToFunc()
+}
+
+// ByParentCode orders the results by the parent_code field.
+func ByParentCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldParentCode, opts...).ToFunc()
+}
+
+// ByPath orders the results by the path field.
+func ByPath(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPath, opts...).ToFunc()
+}
+
+// ByIcon orders the results by the icon field.
+func ByIcon(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIcon, opts...).ToFunc()
+}
+
+// BySort orders the results by the sort field.
+func BySort(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSort, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/permission/where.go b/bj_power_wms/permission/where.go
new file mode 100644
index 0000000..2a58c1f
--- /dev/null
+++ b/bj_power_wms/permission/where.go
@@ -0,0 +1,744 @@
+// Code generated by ent, DO NOT EDIT.
+
+package permission
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldID, id))
+}
+
+// Code applies equality check predicate on the "code" field. It's identical to CodeEQ.
+func Code(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldCode, v))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldName, v))
+}
+
+// Type applies equality check predicate on the "type" field. It's identical to TypeEQ.
+func Type(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldType, v))
+}
+
+// ParentCode applies equality check predicate on the "parent_code" field. It's identical to ParentCodeEQ.
+func ParentCode(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldParentCode, v))
+}
+
+// Path applies equality check predicate on the "path" field. It's identical to PathEQ.
+func Path(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldPath, v))
+}
+
+// Icon applies equality check predicate on the "icon" field. It's identical to IconEQ.
+func Icon(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldIcon, v))
+}
+
+// Sort applies equality check predicate on the "sort" field. It's identical to SortEQ.
+func Sort(v int) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldSort, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldRemark, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// CodeEQ applies the EQ predicate on the "code" field.
+func CodeEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldCode, v))
+}
+
+// CodeNEQ applies the NEQ predicate on the "code" field.
+func CodeNEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldCode, v))
+}
+
+// CodeIn applies the In predicate on the "code" field.
+func CodeIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldCode, vs...))
+}
+
+// CodeNotIn applies the NotIn predicate on the "code" field.
+func CodeNotIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldCode, vs...))
+}
+
+// CodeGT applies the GT predicate on the "code" field.
+func CodeGT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldCode, v))
+}
+
+// CodeGTE applies the GTE predicate on the "code" field.
+func CodeGTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldCode, v))
+}
+
+// CodeLT applies the LT predicate on the "code" field.
+func CodeLT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldCode, v))
+}
+
+// CodeLTE applies the LTE predicate on the "code" field.
+func CodeLTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldCode, v))
+}
+
+// CodeContains applies the Contains predicate on the "code" field.
+func CodeContains(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContains(FieldCode, v))
+}
+
+// CodeHasPrefix applies the HasPrefix predicate on the "code" field.
+func CodeHasPrefix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasPrefix(FieldCode, v))
+}
+
+// CodeHasSuffix applies the HasSuffix predicate on the "code" field.
+func CodeHasSuffix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasSuffix(FieldCode, v))
+}
+
+// CodeEqualFold applies the EqualFold predicate on the "code" field.
+func CodeEqualFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEqualFold(FieldCode, v))
+}
+
+// CodeContainsFold applies the ContainsFold predicate on the "code" field.
+func CodeContainsFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContainsFold(FieldCode, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContainsFold(FieldName, v))
+}
+
+// TypeEQ applies the EQ predicate on the "type" field.
+func TypeEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldType, v))
+}
+
+// TypeNEQ applies the NEQ predicate on the "type" field.
+func TypeNEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldType, v))
+}
+
+// TypeIn applies the In predicate on the "type" field.
+func TypeIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldType, vs...))
+}
+
+// TypeNotIn applies the NotIn predicate on the "type" field.
+func TypeNotIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldType, vs...))
+}
+
+// TypeGT applies the GT predicate on the "type" field.
+func TypeGT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldType, v))
+}
+
+// TypeGTE applies the GTE predicate on the "type" field.
+func TypeGTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldType, v))
+}
+
+// TypeLT applies the LT predicate on the "type" field.
+func TypeLT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldType, v))
+}
+
+// TypeLTE applies the LTE predicate on the "type" field.
+func TypeLTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldType, v))
+}
+
+// TypeContains applies the Contains predicate on the "type" field.
+func TypeContains(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContains(FieldType, v))
+}
+
+// TypeHasPrefix applies the HasPrefix predicate on the "type" field.
+func TypeHasPrefix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasPrefix(FieldType, v))
+}
+
+// TypeHasSuffix applies the HasSuffix predicate on the "type" field.
+func TypeHasSuffix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasSuffix(FieldType, v))
+}
+
+// TypeEqualFold applies the EqualFold predicate on the "type" field.
+func TypeEqualFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEqualFold(FieldType, v))
+}
+
+// TypeContainsFold applies the ContainsFold predicate on the "type" field.
+func TypeContainsFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContainsFold(FieldType, v))
+}
+
+// ParentCodeEQ applies the EQ predicate on the "parent_code" field.
+func ParentCodeEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldParentCode, v))
+}
+
+// ParentCodeNEQ applies the NEQ predicate on the "parent_code" field.
+func ParentCodeNEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldParentCode, v))
+}
+
+// ParentCodeIn applies the In predicate on the "parent_code" field.
+func ParentCodeIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldParentCode, vs...))
+}
+
+// ParentCodeNotIn applies the NotIn predicate on the "parent_code" field.
+func ParentCodeNotIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldParentCode, vs...))
+}
+
+// ParentCodeGT applies the GT predicate on the "parent_code" field.
+func ParentCodeGT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldParentCode, v))
+}
+
+// ParentCodeGTE applies the GTE predicate on the "parent_code" field.
+func ParentCodeGTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldParentCode, v))
+}
+
+// ParentCodeLT applies the LT predicate on the "parent_code" field.
+func ParentCodeLT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldParentCode, v))
+}
+
+// ParentCodeLTE applies the LTE predicate on the "parent_code" field.
+func ParentCodeLTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldParentCode, v))
+}
+
+// ParentCodeContains applies the Contains predicate on the "parent_code" field.
+func ParentCodeContains(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContains(FieldParentCode, v))
+}
+
+// ParentCodeHasPrefix applies the HasPrefix predicate on the "parent_code" field.
+func ParentCodeHasPrefix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasPrefix(FieldParentCode, v))
+}
+
+// ParentCodeHasSuffix applies the HasSuffix predicate on the "parent_code" field.
+func ParentCodeHasSuffix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasSuffix(FieldParentCode, v))
+}
+
+// ParentCodeIsNil applies the IsNil predicate on the "parent_code" field.
+func ParentCodeIsNil() predicate.Permission {
+	return predicate.Permission(sql.FieldIsNull(FieldParentCode))
+}
+
+// ParentCodeNotNil applies the NotNil predicate on the "parent_code" field.
+func ParentCodeNotNil() predicate.Permission {
+	return predicate.Permission(sql.FieldNotNull(FieldParentCode))
+}
+
+// ParentCodeEqualFold applies the EqualFold predicate on the "parent_code" field.
+func ParentCodeEqualFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEqualFold(FieldParentCode, v))
+}
+
+// ParentCodeContainsFold applies the ContainsFold predicate on the "parent_code" field.
+func ParentCodeContainsFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContainsFold(FieldParentCode, v))
+}
+
+// PathEQ applies the EQ predicate on the "path" field.
+func PathEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldPath, v))
+}
+
+// PathNEQ applies the NEQ predicate on the "path" field.
+func PathNEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldPath, v))
+}
+
+// PathIn applies the In predicate on the "path" field.
+func PathIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldPath, vs...))
+}
+
+// PathNotIn applies the NotIn predicate on the "path" field.
+func PathNotIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldPath, vs...))
+}
+
+// PathGT applies the GT predicate on the "path" field.
+func PathGT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldPath, v))
+}
+
+// PathGTE applies the GTE predicate on the "path" field.
+func PathGTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldPath, v))
+}
+
+// PathLT applies the LT predicate on the "path" field.
+func PathLT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldPath, v))
+}
+
+// PathLTE applies the LTE predicate on the "path" field.
+func PathLTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldPath, v))
+}
+
+// PathContains applies the Contains predicate on the "path" field.
+func PathContains(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContains(FieldPath, v))
+}
+
+// PathHasPrefix applies the HasPrefix predicate on the "path" field.
+func PathHasPrefix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasPrefix(FieldPath, v))
+}
+
+// PathHasSuffix applies the HasSuffix predicate on the "path" field.
+func PathHasSuffix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasSuffix(FieldPath, v))
+}
+
+// PathIsNil applies the IsNil predicate on the "path" field.
+func PathIsNil() predicate.Permission {
+	return predicate.Permission(sql.FieldIsNull(FieldPath))
+}
+
+// PathNotNil applies the NotNil predicate on the "path" field.
+func PathNotNil() predicate.Permission {
+	return predicate.Permission(sql.FieldNotNull(FieldPath))
+}
+
+// PathEqualFold applies the EqualFold predicate on the "path" field.
+func PathEqualFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEqualFold(FieldPath, v))
+}
+
+// PathContainsFold applies the ContainsFold predicate on the "path" field.
+func PathContainsFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContainsFold(FieldPath, v))
+}
+
+// IconEQ applies the EQ predicate on the "icon" field.
+func IconEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldIcon, v))
+}
+
+// IconNEQ applies the NEQ predicate on the "icon" field.
+func IconNEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldIcon, v))
+}
+
+// IconIn applies the In predicate on the "icon" field.
+func IconIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldIcon, vs...))
+}
+
+// IconNotIn applies the NotIn predicate on the "icon" field.
+func IconNotIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldIcon, vs...))
+}
+
+// IconGT applies the GT predicate on the "icon" field.
+func IconGT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldIcon, v))
+}
+
+// IconGTE applies the GTE predicate on the "icon" field.
+func IconGTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldIcon, v))
+}
+
+// IconLT applies the LT predicate on the "icon" field.
+func IconLT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldIcon, v))
+}
+
+// IconLTE applies the LTE predicate on the "icon" field.
+func IconLTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldIcon, v))
+}
+
+// IconContains applies the Contains predicate on the "icon" field.
+func IconContains(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContains(FieldIcon, v))
+}
+
+// IconHasPrefix applies the HasPrefix predicate on the "icon" field.
+func IconHasPrefix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasPrefix(FieldIcon, v))
+}
+
+// IconHasSuffix applies the HasSuffix predicate on the "icon" field.
+func IconHasSuffix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasSuffix(FieldIcon, v))
+}
+
+// IconIsNil applies the IsNil predicate on the "icon" field.
+func IconIsNil() predicate.Permission {
+	return predicate.Permission(sql.FieldIsNull(FieldIcon))
+}
+
+// IconNotNil applies the NotNil predicate on the "icon" field.
+func IconNotNil() predicate.Permission {
+	return predicate.Permission(sql.FieldNotNull(FieldIcon))
+}
+
+// IconEqualFold applies the EqualFold predicate on the "icon" field.
+func IconEqualFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEqualFold(FieldIcon, v))
+}
+
+// IconContainsFold applies the ContainsFold predicate on the "icon" field.
+func IconContainsFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContainsFold(FieldIcon, v))
+}
+
+// SortEQ applies the EQ predicate on the "sort" field.
+func SortEQ(v int) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldSort, v))
+}
+
+// SortNEQ applies the NEQ predicate on the "sort" field.
+func SortNEQ(v int) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldSort, v))
+}
+
+// SortIn applies the In predicate on the "sort" field.
+func SortIn(vs ...int) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldSort, vs...))
+}
+
+// SortNotIn applies the NotIn predicate on the "sort" field.
+func SortNotIn(vs ...int) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldSort, vs...))
+}
+
+// SortGT applies the GT predicate on the "sort" field.
+func SortGT(v int) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldSort, v))
+}
+
+// SortGTE applies the GTE predicate on the "sort" field.
+func SortGTE(v int) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldSort, v))
+}
+
+// SortLT applies the LT predicate on the "sort" field.
+func SortLT(v int) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldSort, v))
+}
+
+// SortLTE applies the LTE predicate on the "sort" field.
+func SortLTE(v int) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldSort, v))
+}
+
+// SortIsNil applies the IsNil predicate on the "sort" field.
+func SortIsNil() predicate.Permission {
+	return predicate.Permission(sql.FieldIsNull(FieldSort))
+}
+
+// SortNotNil applies the NotNil predicate on the "sort" field.
+func SortNotNil() predicate.Permission {
+	return predicate.Permission(sql.FieldNotNull(FieldSort))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.Permission {
+	return predicate.Permission(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.Permission {
+	return predicate.Permission(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.Permission {
+	return predicate.Permission(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.Permission {
+	return predicate.Permission(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.Permission {
+	return predicate.Permission(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.Permission {
+	return predicate.Permission(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Permission) predicate.Permission {
+	return predicate.Permission(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Permission) predicate.Permission {
+	return predicate.Permission(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Permission) predicate.Permission {
+	return predicate.Permission(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/predicate/predicate.go b/bj_power_wms/predicate/predicate.go
new file mode 100644
index 0000000..2301019
--- /dev/null
+++ b/bj_power_wms/predicate/predicate.go
@@ -0,0 +1,70 @@
+// Code generated by ent, DO NOT EDIT.
+
+package predicate
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+// AgvTask is the predicate function for agvtask builders.
+type AgvTask func(*sql.Selector)
+
+// Attachment is the predicate function for attachment builders.
+type Attachment func(*sql.Selector)
+
+// EventLog is the predicate function for eventlog builders.
+type EventLog func(*sql.Selector)
+
+// InboundDetail is the predicate function for inbounddetail builders.
+type InboundDetail func(*sql.Selector)
+
+// InboundOrder is the predicate function for inboundorder builders.
+type InboundOrder func(*sql.Selector)
+
+// InspectionRecord is the predicate function for inspectionrecord builders.
+type InspectionRecord func(*sql.Selector)
+
+// Inventory is the predicate function for inventory builders.
+type Inventory func(*sql.Selector)
+
+// InventoryLock is the predicate function for inventorylock builders.
+type InventoryLock func(*sql.Selector)
+
+// Material is the predicate function for material builders.
+type Material func(*sql.Selector)
+
+// MaterialDemand is the predicate function for materialdemand builders.
+type MaterialDemand func(*sql.Selector)
+
+// OrderMaterialLedger is the predicate function for ordermaterialledger builders.
+type OrderMaterialLedger func(*sql.Selector)
+
+// OutboundDetail is the predicate function for outbounddetail builders.
+type OutboundDetail func(*sql.Selector)
+
+// OutboundOrder is the predicate function for outboundorder builders.
+type OutboundOrder func(*sql.Selector)
+
+// Permission is the predicate function for permission builders.
+type Permission func(*sql.Selector)
+
+// ReturnOrder is the predicate function for returnorder builders.
+type ReturnOrder func(*sql.Selector)
+
+// Role is the predicate function for role builders.
+type Role func(*sql.Selector)
+
+// SemiFinished is the predicate function for semifinished builders.
+type SemiFinished func(*sql.Selector)
+
+// StocktakeItem is the predicate function for stocktakeitem builders.
+type StocktakeItem func(*sql.Selector)
+
+// StocktakeOrder is the predicate function for stocktakeorder builders.
+type StocktakeOrder func(*sql.Selector)
+
+// User is the predicate function for user builders.
+type User func(*sql.Selector)
+
+// Zone is the predicate function for zone builders.
+type Zone func(*sql.Selector)
diff --git a/bj_power_wms/returnorder/returnorder.go b/bj_power_wms/returnorder/returnorder.go
new file mode 100644
index 0000000..182e046
--- /dev/null
+++ b/bj_power_wms/returnorder/returnorder.go
@@ -0,0 +1,194 @@
+// Code generated by ent, DO NOT EDIT.
+
+package returnorder
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the returnorder type in the database.
+	Label = "return_order"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldReturnNo holds the string denoting the return_no field in the database.
+	FieldReturnNo = "return_no"
+	// FieldSourceType holds the string denoting the source_type field in the database.
+	FieldSourceType = "source_type"
+	// FieldOrderNo holds the string denoting the order_no field in the database.
+	FieldOrderNo = "order_no"
+	// FieldStationNo holds the string denoting the station_no field in the database.
+	FieldStationNo = "station_no"
+	// FieldSn holds the string denoting the sn field in the database.
+	FieldSn = "sn"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldMaterialName holds the string denoting the material_name field in the database.
+	FieldMaterialName = "material_name"
+	// FieldSpec holds the string denoting the spec field in the database.
+	FieldSpec = "spec"
+	// FieldQty holds the string denoting the qty field in the database.
+	FieldQty = "qty"
+	// FieldUnit holds the string denoting the unit field in the database.
+	FieldUnit = "unit"
+	// FieldReason holds the string denoting the reason field in the database.
+	FieldReason = "reason"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldOperator holds the string denoting the operator field in the database.
+	FieldOperator = "operator"
+	// FieldReceiveBy holds the string denoting the receive_by field in the database.
+	FieldReceiveBy = "receive_by"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldReceiveAt holds the string denoting the receive_at field in the database.
+	FieldReceiveAt = "receive_at"
+	// Table holds the table name of the returnorder in the database.
+	Table = "return_orders"
+)
+
+// Columns holds all SQL columns for returnorder fields.
+var Columns = []string{
+	FieldID,
+	FieldReturnNo,
+	FieldSourceType,
+	FieldOrderNo,
+	FieldStationNo,
+	FieldSn,
+	FieldMaterialCode,
+	FieldMaterialName,
+	FieldSpec,
+	FieldQty,
+	FieldUnit,
+	FieldReason,
+	FieldStatus,
+	FieldOperator,
+	FieldReceiveBy,
+	FieldCreatedAt,
+	FieldReceiveAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultSourceType holds the default value on creation for the "source_type" field.
+	DefaultSourceType string
+	// DefaultOrderNo holds the default value on creation for the "order_no" field.
+	DefaultOrderNo string
+	// DefaultStationNo holds the default value on creation for the "station_no" field.
+	DefaultStationNo int
+	// DefaultSn holds the default value on creation for the "sn" field.
+	DefaultSn string
+	// DefaultQty holds the default value on creation for the "qty" field.
+	DefaultQty int
+	// DefaultUnit holds the default value on creation for the "unit" field.
+	DefaultUnit string
+	// DefaultReason holds the default value on creation for the "reason" field.
+	DefaultReason string
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultOperator holds the default value on creation for the "operator" field.
+	DefaultOperator string
+	// DefaultReceiveBy holds the default value on creation for the "receive_by" field.
+	DefaultReceiveBy string
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultReceiveAt holds the default value on creation for the "receive_at" field.
+	DefaultReceiveAt int64
+)
+
+// OrderOption defines the ordering options for the ReturnOrder queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByReturnNo orders the results by the return_no field.
+func ByReturnNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReturnNo, opts...).ToFunc()
+}
+
+// BySourceType orders the results by the source_type field.
+func BySourceType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSourceType, opts...).ToFunc()
+}
+
+// ByOrderNo orders the results by the order_no field.
+func ByOrderNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOrderNo, opts...).ToFunc()
+}
+
+// ByStationNo orders the results by the station_no field.
+func ByStationNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStationNo, opts...).ToFunc()
+}
+
+// BySn orders the results by the sn field.
+func BySn(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSn, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByMaterialName orders the results by the material_name field.
+func ByMaterialName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialName, opts...).ToFunc()
+}
+
+// BySpec orders the results by the spec field.
+func BySpec(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSpec, opts...).ToFunc()
+}
+
+// ByQty orders the results by the qty field.
+func ByQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQty, opts...).ToFunc()
+}
+
+// ByUnit orders the results by the unit field.
+func ByUnit(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUnit, opts...).ToFunc()
+}
+
+// ByReason orders the results by the reason field.
+func ByReason(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReason, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByOperator orders the results by the operator field.
+func ByOperator(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOperator, opts...).ToFunc()
+}
+
+// ByReceiveBy orders the results by the receive_by field.
+func ByReceiveBy(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReceiveBy, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByReceiveAt orders the results by the receive_at field.
+func ByReceiveAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldReceiveAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/returnorder/where.go b/bj_power_wms/returnorder/where.go
new file mode 100644
index 0000000..435ef58
--- /dev/null
+++ b/bj_power_wms/returnorder/where.go
@@ -0,0 +1,1109 @@
+// Code generated by ent, DO NOT EDIT.
+
+package returnorder
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldID, id))
+}
+
+// ReturnNo applies equality check predicate on the "return_no" field. It's identical to ReturnNoEQ.
+func ReturnNo(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldReturnNo, v))
+}
+
+// SourceType applies equality check predicate on the "source_type" field. It's identical to SourceTypeEQ.
+func SourceType(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldSourceType, v))
+}
+
+// OrderNo applies equality check predicate on the "order_no" field. It's identical to OrderNoEQ.
+func OrderNo(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// StationNo applies equality check predicate on the "station_no" field. It's identical to StationNoEQ.
+func StationNo(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldStationNo, v))
+}
+
+// Sn applies equality check predicate on the "sn" field. It's identical to SnEQ.
+func Sn(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldSn, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialName applies equality check predicate on the "material_name" field. It's identical to MaterialNameEQ.
+func MaterialName(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// Spec applies equality check predicate on the "spec" field. It's identical to SpecEQ.
+func Spec(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldSpec, v))
+}
+
+// Qty applies equality check predicate on the "qty" field. It's identical to QtyEQ.
+func Qty(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldQty, v))
+}
+
+// Unit applies equality check predicate on the "unit" field. It's identical to UnitEQ.
+func Unit(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldUnit, v))
+}
+
+// Reason applies equality check predicate on the "reason" field. It's identical to ReasonEQ.
+func Reason(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldReason, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldStatus, v))
+}
+
+// Operator applies equality check predicate on the "operator" field. It's identical to OperatorEQ.
+func Operator(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldOperator, v))
+}
+
+// ReceiveBy applies equality check predicate on the "receive_by" field. It's identical to ReceiveByEQ.
+func ReceiveBy(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldReceiveBy, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// ReceiveAt applies equality check predicate on the "receive_at" field. It's identical to ReceiveAtEQ.
+func ReceiveAt(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldReceiveAt, v))
+}
+
+// ReturnNoEQ applies the EQ predicate on the "return_no" field.
+func ReturnNoEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldReturnNo, v))
+}
+
+// ReturnNoNEQ applies the NEQ predicate on the "return_no" field.
+func ReturnNoNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldReturnNo, v))
+}
+
+// ReturnNoIn applies the In predicate on the "return_no" field.
+func ReturnNoIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldReturnNo, vs...))
+}
+
+// ReturnNoNotIn applies the NotIn predicate on the "return_no" field.
+func ReturnNoNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldReturnNo, vs...))
+}
+
+// ReturnNoGT applies the GT predicate on the "return_no" field.
+func ReturnNoGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldReturnNo, v))
+}
+
+// ReturnNoGTE applies the GTE predicate on the "return_no" field.
+func ReturnNoGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldReturnNo, v))
+}
+
+// ReturnNoLT applies the LT predicate on the "return_no" field.
+func ReturnNoLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldReturnNo, v))
+}
+
+// ReturnNoLTE applies the LTE predicate on the "return_no" field.
+func ReturnNoLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldReturnNo, v))
+}
+
+// ReturnNoContains applies the Contains predicate on the "return_no" field.
+func ReturnNoContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldReturnNo, v))
+}
+
+// ReturnNoHasPrefix applies the HasPrefix predicate on the "return_no" field.
+func ReturnNoHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldReturnNo, v))
+}
+
+// ReturnNoHasSuffix applies the HasSuffix predicate on the "return_no" field.
+func ReturnNoHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldReturnNo, v))
+}
+
+// ReturnNoEqualFold applies the EqualFold predicate on the "return_no" field.
+func ReturnNoEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldReturnNo, v))
+}
+
+// ReturnNoContainsFold applies the ContainsFold predicate on the "return_no" field.
+func ReturnNoContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldReturnNo, v))
+}
+
+// SourceTypeEQ applies the EQ predicate on the "source_type" field.
+func SourceTypeEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldSourceType, v))
+}
+
+// SourceTypeNEQ applies the NEQ predicate on the "source_type" field.
+func SourceTypeNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldSourceType, v))
+}
+
+// SourceTypeIn applies the In predicate on the "source_type" field.
+func SourceTypeIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldSourceType, vs...))
+}
+
+// SourceTypeNotIn applies the NotIn predicate on the "source_type" field.
+func SourceTypeNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldSourceType, vs...))
+}
+
+// SourceTypeGT applies the GT predicate on the "source_type" field.
+func SourceTypeGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldSourceType, v))
+}
+
+// SourceTypeGTE applies the GTE predicate on the "source_type" field.
+func SourceTypeGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldSourceType, v))
+}
+
+// SourceTypeLT applies the LT predicate on the "source_type" field.
+func SourceTypeLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldSourceType, v))
+}
+
+// SourceTypeLTE applies the LTE predicate on the "source_type" field.
+func SourceTypeLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldSourceType, v))
+}
+
+// SourceTypeContains applies the Contains predicate on the "source_type" field.
+func SourceTypeContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldSourceType, v))
+}
+
+// SourceTypeHasPrefix applies the HasPrefix predicate on the "source_type" field.
+func SourceTypeHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldSourceType, v))
+}
+
+// SourceTypeHasSuffix applies the HasSuffix predicate on the "source_type" field.
+func SourceTypeHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldSourceType, v))
+}
+
+// SourceTypeEqualFold applies the EqualFold predicate on the "source_type" field.
+func SourceTypeEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldSourceType, v))
+}
+
+// SourceTypeContainsFold applies the ContainsFold predicate on the "source_type" field.
+func SourceTypeContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldSourceType, v))
+}
+
+// OrderNoEQ applies the EQ predicate on the "order_no" field.
+func OrderNoEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// OrderNoNEQ applies the NEQ predicate on the "order_no" field.
+func OrderNoNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldOrderNo, v))
+}
+
+// OrderNoIn applies the In predicate on the "order_no" field.
+func OrderNoIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldOrderNo, vs...))
+}
+
+// OrderNoNotIn applies the NotIn predicate on the "order_no" field.
+func OrderNoNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldOrderNo, vs...))
+}
+
+// OrderNoGT applies the GT predicate on the "order_no" field.
+func OrderNoGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldOrderNo, v))
+}
+
+// OrderNoGTE applies the GTE predicate on the "order_no" field.
+func OrderNoGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldOrderNo, v))
+}
+
+// OrderNoLT applies the LT predicate on the "order_no" field.
+func OrderNoLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldOrderNo, v))
+}
+
+// OrderNoLTE applies the LTE predicate on the "order_no" field.
+func OrderNoLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldOrderNo, v))
+}
+
+// OrderNoContains applies the Contains predicate on the "order_no" field.
+func OrderNoContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldOrderNo, v))
+}
+
+// OrderNoHasPrefix applies the HasPrefix predicate on the "order_no" field.
+func OrderNoHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldOrderNo, v))
+}
+
+// OrderNoHasSuffix applies the HasSuffix predicate on the "order_no" field.
+func OrderNoHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldOrderNo, v))
+}
+
+// OrderNoEqualFold applies the EqualFold predicate on the "order_no" field.
+func OrderNoEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldOrderNo, v))
+}
+
+// OrderNoContainsFold applies the ContainsFold predicate on the "order_no" field.
+func OrderNoContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldOrderNo, v))
+}
+
+// StationNoEQ applies the EQ predicate on the "station_no" field.
+func StationNoEQ(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldStationNo, v))
+}
+
+// StationNoNEQ applies the NEQ predicate on the "station_no" field.
+func StationNoNEQ(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldStationNo, v))
+}
+
+// StationNoIn applies the In predicate on the "station_no" field.
+func StationNoIn(vs ...int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldStationNo, vs...))
+}
+
+// StationNoNotIn applies the NotIn predicate on the "station_no" field.
+func StationNoNotIn(vs ...int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldStationNo, vs...))
+}
+
+// StationNoGT applies the GT predicate on the "station_no" field.
+func StationNoGT(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldStationNo, v))
+}
+
+// StationNoGTE applies the GTE predicate on the "station_no" field.
+func StationNoGTE(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldStationNo, v))
+}
+
+// StationNoLT applies the LT predicate on the "station_no" field.
+func StationNoLT(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldStationNo, v))
+}
+
+// StationNoLTE applies the LTE predicate on the "station_no" field.
+func StationNoLTE(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldStationNo, v))
+}
+
+// SnEQ applies the EQ predicate on the "sn" field.
+func SnEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldSn, v))
+}
+
+// SnNEQ applies the NEQ predicate on the "sn" field.
+func SnNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldSn, v))
+}
+
+// SnIn applies the In predicate on the "sn" field.
+func SnIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldSn, vs...))
+}
+
+// SnNotIn applies the NotIn predicate on the "sn" field.
+func SnNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldSn, vs...))
+}
+
+// SnGT applies the GT predicate on the "sn" field.
+func SnGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldSn, v))
+}
+
+// SnGTE applies the GTE predicate on the "sn" field.
+func SnGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldSn, v))
+}
+
+// SnLT applies the LT predicate on the "sn" field.
+func SnLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldSn, v))
+}
+
+// SnLTE applies the LTE predicate on the "sn" field.
+func SnLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldSn, v))
+}
+
+// SnContains applies the Contains predicate on the "sn" field.
+func SnContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldSn, v))
+}
+
+// SnHasPrefix applies the HasPrefix predicate on the "sn" field.
+func SnHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldSn, v))
+}
+
+// SnHasSuffix applies the HasSuffix predicate on the "sn" field.
+func SnHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldSn, v))
+}
+
+// SnEqualFold applies the EqualFold predicate on the "sn" field.
+func SnEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldSn, v))
+}
+
+// SnContainsFold applies the ContainsFold predicate on the "sn" field.
+func SnContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldSn, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// MaterialNameEQ applies the EQ predicate on the "material_name" field.
+func MaterialNameEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldMaterialName, v))
+}
+
+// MaterialNameNEQ applies the NEQ predicate on the "material_name" field.
+func MaterialNameNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldMaterialName, v))
+}
+
+// MaterialNameIn applies the In predicate on the "material_name" field.
+func MaterialNameIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameNotIn applies the NotIn predicate on the "material_name" field.
+func MaterialNameNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldMaterialName, vs...))
+}
+
+// MaterialNameGT applies the GT predicate on the "material_name" field.
+func MaterialNameGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldMaterialName, v))
+}
+
+// MaterialNameGTE applies the GTE predicate on the "material_name" field.
+func MaterialNameGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldMaterialName, v))
+}
+
+// MaterialNameLT applies the LT predicate on the "material_name" field.
+func MaterialNameLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldMaterialName, v))
+}
+
+// MaterialNameLTE applies the LTE predicate on the "material_name" field.
+func MaterialNameLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldMaterialName, v))
+}
+
+// MaterialNameContains applies the Contains predicate on the "material_name" field.
+func MaterialNameContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldMaterialName, v))
+}
+
+// MaterialNameHasPrefix applies the HasPrefix predicate on the "material_name" field.
+func MaterialNameHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldMaterialName, v))
+}
+
+// MaterialNameHasSuffix applies the HasSuffix predicate on the "material_name" field.
+func MaterialNameHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldMaterialName, v))
+}
+
+// MaterialNameIsNil applies the IsNil predicate on the "material_name" field.
+func MaterialNameIsNil() predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIsNull(FieldMaterialName))
+}
+
+// MaterialNameNotNil applies the NotNil predicate on the "material_name" field.
+func MaterialNameNotNil() predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotNull(FieldMaterialName))
+}
+
+// MaterialNameEqualFold applies the EqualFold predicate on the "material_name" field.
+func MaterialNameEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldMaterialName, v))
+}
+
+// MaterialNameContainsFold applies the ContainsFold predicate on the "material_name" field.
+func MaterialNameContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldMaterialName, v))
+}
+
+// SpecEQ applies the EQ predicate on the "spec" field.
+func SpecEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldSpec, v))
+}
+
+// SpecNEQ applies the NEQ predicate on the "spec" field.
+func SpecNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldSpec, v))
+}
+
+// SpecIn applies the In predicate on the "spec" field.
+func SpecIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldSpec, vs...))
+}
+
+// SpecNotIn applies the NotIn predicate on the "spec" field.
+func SpecNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldSpec, vs...))
+}
+
+// SpecGT applies the GT predicate on the "spec" field.
+func SpecGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldSpec, v))
+}
+
+// SpecGTE applies the GTE predicate on the "spec" field.
+func SpecGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldSpec, v))
+}
+
+// SpecLT applies the LT predicate on the "spec" field.
+func SpecLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldSpec, v))
+}
+
+// SpecLTE applies the LTE predicate on the "spec" field.
+func SpecLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldSpec, v))
+}
+
+// SpecContains applies the Contains predicate on the "spec" field.
+func SpecContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldSpec, v))
+}
+
+// SpecHasPrefix applies the HasPrefix predicate on the "spec" field.
+func SpecHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldSpec, v))
+}
+
+// SpecHasSuffix applies the HasSuffix predicate on the "spec" field.
+func SpecHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldSpec, v))
+}
+
+// SpecIsNil applies the IsNil predicate on the "spec" field.
+func SpecIsNil() predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIsNull(FieldSpec))
+}
+
+// SpecNotNil applies the NotNil predicate on the "spec" field.
+func SpecNotNil() predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotNull(FieldSpec))
+}
+
+// SpecEqualFold applies the EqualFold predicate on the "spec" field.
+func SpecEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldSpec, v))
+}
+
+// SpecContainsFold applies the ContainsFold predicate on the "spec" field.
+func SpecContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldSpec, v))
+}
+
+// QtyEQ applies the EQ predicate on the "qty" field.
+func QtyEQ(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldQty, v))
+}
+
+// QtyNEQ applies the NEQ predicate on the "qty" field.
+func QtyNEQ(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldQty, v))
+}
+
+// QtyIn applies the In predicate on the "qty" field.
+func QtyIn(vs ...int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldQty, vs...))
+}
+
+// QtyNotIn applies the NotIn predicate on the "qty" field.
+func QtyNotIn(vs ...int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldQty, vs...))
+}
+
+// QtyGT applies the GT predicate on the "qty" field.
+func QtyGT(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldQty, v))
+}
+
+// QtyGTE applies the GTE predicate on the "qty" field.
+func QtyGTE(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldQty, v))
+}
+
+// QtyLT applies the LT predicate on the "qty" field.
+func QtyLT(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldQty, v))
+}
+
+// QtyLTE applies the LTE predicate on the "qty" field.
+func QtyLTE(v int) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldQty, v))
+}
+
+// UnitEQ applies the EQ predicate on the "unit" field.
+func UnitEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldUnit, v))
+}
+
+// UnitNEQ applies the NEQ predicate on the "unit" field.
+func UnitNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldUnit, v))
+}
+
+// UnitIn applies the In predicate on the "unit" field.
+func UnitIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldUnit, vs...))
+}
+
+// UnitNotIn applies the NotIn predicate on the "unit" field.
+func UnitNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldUnit, vs...))
+}
+
+// UnitGT applies the GT predicate on the "unit" field.
+func UnitGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldUnit, v))
+}
+
+// UnitGTE applies the GTE predicate on the "unit" field.
+func UnitGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldUnit, v))
+}
+
+// UnitLT applies the LT predicate on the "unit" field.
+func UnitLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldUnit, v))
+}
+
+// UnitLTE applies the LTE predicate on the "unit" field.
+func UnitLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldUnit, v))
+}
+
+// UnitContains applies the Contains predicate on the "unit" field.
+func UnitContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldUnit, v))
+}
+
+// UnitHasPrefix applies the HasPrefix predicate on the "unit" field.
+func UnitHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldUnit, v))
+}
+
+// UnitHasSuffix applies the HasSuffix predicate on the "unit" field.
+func UnitHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldUnit, v))
+}
+
+// UnitEqualFold applies the EqualFold predicate on the "unit" field.
+func UnitEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldUnit, v))
+}
+
+// UnitContainsFold applies the ContainsFold predicate on the "unit" field.
+func UnitContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldUnit, v))
+}
+
+// ReasonEQ applies the EQ predicate on the "reason" field.
+func ReasonEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldReason, v))
+}
+
+// ReasonNEQ applies the NEQ predicate on the "reason" field.
+func ReasonNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldReason, v))
+}
+
+// ReasonIn applies the In predicate on the "reason" field.
+func ReasonIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldReason, vs...))
+}
+
+// ReasonNotIn applies the NotIn predicate on the "reason" field.
+func ReasonNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldReason, vs...))
+}
+
+// ReasonGT applies the GT predicate on the "reason" field.
+func ReasonGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldReason, v))
+}
+
+// ReasonGTE applies the GTE predicate on the "reason" field.
+func ReasonGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldReason, v))
+}
+
+// ReasonLT applies the LT predicate on the "reason" field.
+func ReasonLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldReason, v))
+}
+
+// ReasonLTE applies the LTE predicate on the "reason" field.
+func ReasonLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldReason, v))
+}
+
+// ReasonContains applies the Contains predicate on the "reason" field.
+func ReasonContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldReason, v))
+}
+
+// ReasonHasPrefix applies the HasPrefix predicate on the "reason" field.
+func ReasonHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldReason, v))
+}
+
+// ReasonHasSuffix applies the HasSuffix predicate on the "reason" field.
+func ReasonHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldReason, v))
+}
+
+// ReasonEqualFold applies the EqualFold predicate on the "reason" field.
+func ReasonEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldReason, v))
+}
+
+// ReasonContainsFold applies the ContainsFold predicate on the "reason" field.
+func ReasonContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldReason, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// OperatorEQ applies the EQ predicate on the "operator" field.
+func OperatorEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldOperator, v))
+}
+
+// OperatorNEQ applies the NEQ predicate on the "operator" field.
+func OperatorNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldOperator, v))
+}
+
+// OperatorIn applies the In predicate on the "operator" field.
+func OperatorIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldOperator, vs...))
+}
+
+// OperatorNotIn applies the NotIn predicate on the "operator" field.
+func OperatorNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldOperator, vs...))
+}
+
+// OperatorGT applies the GT predicate on the "operator" field.
+func OperatorGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldOperator, v))
+}
+
+// OperatorGTE applies the GTE predicate on the "operator" field.
+func OperatorGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldOperator, v))
+}
+
+// OperatorLT applies the LT predicate on the "operator" field.
+func OperatorLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldOperator, v))
+}
+
+// OperatorLTE applies the LTE predicate on the "operator" field.
+func OperatorLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldOperator, v))
+}
+
+// OperatorContains applies the Contains predicate on the "operator" field.
+func OperatorContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldOperator, v))
+}
+
+// OperatorHasPrefix applies the HasPrefix predicate on the "operator" field.
+func OperatorHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldOperator, v))
+}
+
+// OperatorHasSuffix applies the HasSuffix predicate on the "operator" field.
+func OperatorHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldOperator, v))
+}
+
+// OperatorEqualFold applies the EqualFold predicate on the "operator" field.
+func OperatorEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldOperator, v))
+}
+
+// OperatorContainsFold applies the ContainsFold predicate on the "operator" field.
+func OperatorContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldOperator, v))
+}
+
+// ReceiveByEQ applies the EQ predicate on the "receive_by" field.
+func ReceiveByEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldReceiveBy, v))
+}
+
+// ReceiveByNEQ applies the NEQ predicate on the "receive_by" field.
+func ReceiveByNEQ(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldReceiveBy, v))
+}
+
+// ReceiveByIn applies the In predicate on the "receive_by" field.
+func ReceiveByIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldReceiveBy, vs...))
+}
+
+// ReceiveByNotIn applies the NotIn predicate on the "receive_by" field.
+func ReceiveByNotIn(vs ...string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldReceiveBy, vs...))
+}
+
+// ReceiveByGT applies the GT predicate on the "receive_by" field.
+func ReceiveByGT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldReceiveBy, v))
+}
+
+// ReceiveByGTE applies the GTE predicate on the "receive_by" field.
+func ReceiveByGTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldReceiveBy, v))
+}
+
+// ReceiveByLT applies the LT predicate on the "receive_by" field.
+func ReceiveByLT(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldReceiveBy, v))
+}
+
+// ReceiveByLTE applies the LTE predicate on the "receive_by" field.
+func ReceiveByLTE(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldReceiveBy, v))
+}
+
+// ReceiveByContains applies the Contains predicate on the "receive_by" field.
+func ReceiveByContains(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContains(FieldReceiveBy, v))
+}
+
+// ReceiveByHasPrefix applies the HasPrefix predicate on the "receive_by" field.
+func ReceiveByHasPrefix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasPrefix(FieldReceiveBy, v))
+}
+
+// ReceiveByHasSuffix applies the HasSuffix predicate on the "receive_by" field.
+func ReceiveByHasSuffix(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldHasSuffix(FieldReceiveBy, v))
+}
+
+// ReceiveByEqualFold applies the EqualFold predicate on the "receive_by" field.
+func ReceiveByEqualFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEqualFold(FieldReceiveBy, v))
+}
+
+// ReceiveByContainsFold applies the ContainsFold predicate on the "receive_by" field.
+func ReceiveByContainsFold(v string) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldContainsFold(FieldReceiveBy, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// ReceiveAtEQ applies the EQ predicate on the "receive_at" field.
+func ReceiveAtEQ(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldEQ(FieldReceiveAt, v))
+}
+
+// ReceiveAtNEQ applies the NEQ predicate on the "receive_at" field.
+func ReceiveAtNEQ(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNEQ(FieldReceiveAt, v))
+}
+
+// ReceiveAtIn applies the In predicate on the "receive_at" field.
+func ReceiveAtIn(vs ...int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldIn(FieldReceiveAt, vs...))
+}
+
+// ReceiveAtNotIn applies the NotIn predicate on the "receive_at" field.
+func ReceiveAtNotIn(vs ...int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldNotIn(FieldReceiveAt, vs...))
+}
+
+// ReceiveAtGT applies the GT predicate on the "receive_at" field.
+func ReceiveAtGT(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGT(FieldReceiveAt, v))
+}
+
+// ReceiveAtGTE applies the GTE predicate on the "receive_at" field.
+func ReceiveAtGTE(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldGTE(FieldReceiveAt, v))
+}
+
+// ReceiveAtLT applies the LT predicate on the "receive_at" field.
+func ReceiveAtLT(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLT(FieldReceiveAt, v))
+}
+
+// ReceiveAtLTE applies the LTE predicate on the "receive_at" field.
+func ReceiveAtLTE(v int64) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.FieldLTE(FieldReceiveAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.ReturnOrder) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.ReturnOrder) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.ReturnOrder) predicate.ReturnOrder {
+	return predicate.ReturnOrder(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/role/role.go b/bj_power_wms/role/role.go
new file mode 100644
index 0000000..1a988d6
--- /dev/null
+++ b/bj_power_wms/role/role.go
@@ -0,0 +1,97 @@
+// Code generated by ent, DO NOT EDIT.
+
+package role
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the role type in the database.
+	Label = "role"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldCode holds the string denoting the code field in the database.
+	FieldCode = "code"
+	// FieldRemark holds the string denoting the remark field in the database.
+	FieldRemark = "remark"
+	// FieldPermissionCodes holds the string denoting the permission_codes field in the database.
+	FieldPermissionCodes = "permission_codes"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the role in the database.
+	Table = "roles"
+)
+
+// Columns holds all SQL columns for role fields.
+var Columns = []string{
+	FieldID,
+	FieldName,
+	FieldCode,
+	FieldRemark,
+	FieldPermissionCodes,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// NameValidator is a validator for the "name" field. It is called by the builders before save.
+	NameValidator func(string) error
+	// CodeValidator is a validator for the "code" field. It is called by the builders before save.
+	CodeValidator func(string) error
+	// DefaultRemark holds the default value on creation for the "remark" field.
+	DefaultRemark string
+	// RemarkValidator is a validator for the "remark" field. It is called by the builders before save.
+	RemarkValidator func(string) error
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the Role queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByCode orders the results by the code field.
+func ByCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCode, opts...).ToFunc()
+}
+
+// ByRemark orders the results by the remark field.
+func ByRemark(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRemark, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/role/where.go b/bj_power_wms/role/where.go
new file mode 100644
index 0000000..3230b77
--- /dev/null
+++ b/bj_power_wms/role/where.go
@@ -0,0 +1,389 @@
+// Code generated by ent, DO NOT EDIT.
+
+package role
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.Role {
+	return predicate.Role(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.Role {
+	return predicate.Role(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.Role {
+	return predicate.Role(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.Role {
+	return predicate.Role(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.Role {
+	return predicate.Role(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.Role {
+	return predicate.Role(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.Role {
+	return predicate.Role(sql.FieldLTE(FieldID, id))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldName, v))
+}
+
+// Code applies equality check predicate on the "code" field. It's identical to CodeEQ.
+func Code(v string) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldCode, v))
+}
+
+// Remark applies equality check predicate on the "remark" field. It's identical to RemarkEQ.
+func Remark(v string) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldRemark, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.Role {
+	return predicate.Role(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.Role {
+	return predicate.Role(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.Role {
+	return predicate.Role(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.Role {
+	return predicate.Role(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.Role {
+	return predicate.Role(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.Role {
+	return predicate.Role(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.Role {
+	return predicate.Role(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.Role {
+	return predicate.Role(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.Role {
+	return predicate.Role(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.Role {
+	return predicate.Role(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.Role {
+	return predicate.Role(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.Role {
+	return predicate.Role(sql.FieldContainsFold(FieldName, v))
+}
+
+// CodeEQ applies the EQ predicate on the "code" field.
+func CodeEQ(v string) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldCode, v))
+}
+
+// CodeNEQ applies the NEQ predicate on the "code" field.
+func CodeNEQ(v string) predicate.Role {
+	return predicate.Role(sql.FieldNEQ(FieldCode, v))
+}
+
+// CodeIn applies the In predicate on the "code" field.
+func CodeIn(vs ...string) predicate.Role {
+	return predicate.Role(sql.FieldIn(FieldCode, vs...))
+}
+
+// CodeNotIn applies the NotIn predicate on the "code" field.
+func CodeNotIn(vs ...string) predicate.Role {
+	return predicate.Role(sql.FieldNotIn(FieldCode, vs...))
+}
+
+// CodeGT applies the GT predicate on the "code" field.
+func CodeGT(v string) predicate.Role {
+	return predicate.Role(sql.FieldGT(FieldCode, v))
+}
+
+// CodeGTE applies the GTE predicate on the "code" field.
+func CodeGTE(v string) predicate.Role {
+	return predicate.Role(sql.FieldGTE(FieldCode, v))
+}
+
+// CodeLT applies the LT predicate on the "code" field.
+func CodeLT(v string) predicate.Role {
+	return predicate.Role(sql.FieldLT(FieldCode, v))
+}
+
+// CodeLTE applies the LTE predicate on the "code" field.
+func CodeLTE(v string) predicate.Role {
+	return predicate.Role(sql.FieldLTE(FieldCode, v))
+}
+
+// CodeContains applies the Contains predicate on the "code" field.
+func CodeContains(v string) predicate.Role {
+	return predicate.Role(sql.FieldContains(FieldCode, v))
+}
+
+// CodeHasPrefix applies the HasPrefix predicate on the "code" field.
+func CodeHasPrefix(v string) predicate.Role {
+	return predicate.Role(sql.FieldHasPrefix(FieldCode, v))
+}
+
+// CodeHasSuffix applies the HasSuffix predicate on the "code" field.
+func CodeHasSuffix(v string) predicate.Role {
+	return predicate.Role(sql.FieldHasSuffix(FieldCode, v))
+}
+
+// CodeEqualFold applies the EqualFold predicate on the "code" field.
+func CodeEqualFold(v string) predicate.Role {
+	return predicate.Role(sql.FieldEqualFold(FieldCode, v))
+}
+
+// CodeContainsFold applies the ContainsFold predicate on the "code" field.
+func CodeContainsFold(v string) predicate.Role {
+	return predicate.Role(sql.FieldContainsFold(FieldCode, v))
+}
+
+// RemarkEQ applies the EQ predicate on the "remark" field.
+func RemarkEQ(v string) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldRemark, v))
+}
+
+// RemarkNEQ applies the NEQ predicate on the "remark" field.
+func RemarkNEQ(v string) predicate.Role {
+	return predicate.Role(sql.FieldNEQ(FieldRemark, v))
+}
+
+// RemarkIn applies the In predicate on the "remark" field.
+func RemarkIn(vs ...string) predicate.Role {
+	return predicate.Role(sql.FieldIn(FieldRemark, vs...))
+}
+
+// RemarkNotIn applies the NotIn predicate on the "remark" field.
+func RemarkNotIn(vs ...string) predicate.Role {
+	return predicate.Role(sql.FieldNotIn(FieldRemark, vs...))
+}
+
+// RemarkGT applies the GT predicate on the "remark" field.
+func RemarkGT(v string) predicate.Role {
+	return predicate.Role(sql.FieldGT(FieldRemark, v))
+}
+
+// RemarkGTE applies the GTE predicate on the "remark" field.
+func RemarkGTE(v string) predicate.Role {
+	return predicate.Role(sql.FieldGTE(FieldRemark, v))
+}
+
+// RemarkLT applies the LT predicate on the "remark" field.
+func RemarkLT(v string) predicate.Role {
+	return predicate.Role(sql.FieldLT(FieldRemark, v))
+}
+
+// RemarkLTE applies the LTE predicate on the "remark" field.
+func RemarkLTE(v string) predicate.Role {
+	return predicate.Role(sql.FieldLTE(FieldRemark, v))
+}
+
+// RemarkContains applies the Contains predicate on the "remark" field.
+func RemarkContains(v string) predicate.Role {
+	return predicate.Role(sql.FieldContains(FieldRemark, v))
+}
+
+// RemarkHasPrefix applies the HasPrefix predicate on the "remark" field.
+func RemarkHasPrefix(v string) predicate.Role {
+	return predicate.Role(sql.FieldHasPrefix(FieldRemark, v))
+}
+
+// RemarkHasSuffix applies the HasSuffix predicate on the "remark" field.
+func RemarkHasSuffix(v string) predicate.Role {
+	return predicate.Role(sql.FieldHasSuffix(FieldRemark, v))
+}
+
+// RemarkIsNil applies the IsNil predicate on the "remark" field.
+func RemarkIsNil() predicate.Role {
+	return predicate.Role(sql.FieldIsNull(FieldRemark))
+}
+
+// RemarkNotNil applies the NotNil predicate on the "remark" field.
+func RemarkNotNil() predicate.Role {
+	return predicate.Role(sql.FieldNotNull(FieldRemark))
+}
+
+// RemarkEqualFold applies the EqualFold predicate on the "remark" field.
+func RemarkEqualFold(v string) predicate.Role {
+	return predicate.Role(sql.FieldEqualFold(FieldRemark, v))
+}
+
+// RemarkContainsFold applies the ContainsFold predicate on the "remark" field.
+func RemarkContainsFold(v string) predicate.Role {
+	return predicate.Role(sql.FieldContainsFold(FieldRemark, v))
+}
+
+// PermissionCodesIsNil applies the IsNil predicate on the "permission_codes" field.
+func PermissionCodesIsNil() predicate.Role {
+	return predicate.Role(sql.FieldIsNull(FieldPermissionCodes))
+}
+
+// PermissionCodesNotNil applies the NotNil predicate on the "permission_codes" field.
+func PermissionCodesNotNil() predicate.Role {
+	return predicate.Role(sql.FieldNotNull(FieldPermissionCodes))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.Role {
+	return predicate.Role(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.Role {
+	return predicate.Role(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.Role {
+	return predicate.Role(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.Role {
+	return predicate.Role(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.Role {
+	return predicate.Role(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.Role {
+	return predicate.Role(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.Role {
+	return predicate.Role(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.Role {
+	return predicate.Role(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.Role {
+	return predicate.Role(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.Role {
+	return predicate.Role(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.Role {
+	return predicate.Role(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.Role {
+	return predicate.Role(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.Role {
+	return predicate.Role(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.Role {
+	return predicate.Role(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.Role {
+	return predicate.Role(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Role) predicate.Role {
+	return predicate.Role(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Role) predicate.Role {
+	return predicate.Role(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Role) predicate.Role {
+	return predicate.Role(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/runtime/runtime.go b/bj_power_wms/runtime/runtime.go
new file mode 100644
index 0000000..7a86dd2
--- /dev/null
+++ b/bj_power_wms/runtime/runtime.go
@@ -0,0 +1,10 @@
+// Code generated by ent, DO NOT EDIT.
+
+package runtime
+
+// The schema-stitching logic is generated in bj_power_wms/runtime.go
+
+const (
+	Version = "v0.14.5"                                         // Version of ent codegen.
+	Sum     = "h1:Rj2WOYJtCkWyFo6a+5wB3EfBRP0rnx1fMk6gGA0UUe4=" // Sum of ent codegen.
+)
diff --git a/bj_power_wms/schema/outbound_order.go b/bj_power_wms/schema/outbound_order.go
index 915c4d9..fffed24 100644
--- a/bj_power_wms/schema/outbound_order.go
+++ b/bj_power_wms/schema/outbound_order.go
@@ -52,6 +52,8 @@ func (OutboundOrder) Fields() []ent.Field {
 		field.String("box_no").Optional().Comment("箱号(装箱出库时填写，用于整箱发货追溯)"),
 		field.String("box_sn_list").Optional().Comment("装箱 SN 清单(JSON 数组字符串)"),
 		field.String("contract_no").Optional().Comment("合同号(装箱选填)"),
+		// 检测单号（2026-09-21 对齐入库单字段）：退货/报废等需要溯源检验单据的出库场景可选填写
+		field.String("inspection_no").Optional().Comment("检测单号(溯源关联检验单据)"),
 		field.Int64("created_at").DefaultFunc(nowUnix).Comment("创建时间"),
 	}
 }
@@ -62,5 +64,6 @@ func (OutboundOrder) Indexes() []ent.Index {
 		index.Fields("material_code"),
 		index.Fields("outbound_type"),
 		index.Fields("box_no"),
+		index.Fields("inspection_no"),
 	}
 }
diff --git a/bj_power_wms/semifinished/semifinished.go b/bj_power_wms/semifinished/semifinished.go
new file mode 100644
index 0000000..f92cf07
--- /dev/null
+++ b/bj_power_wms/semifinished/semifinished.go
@@ -0,0 +1,122 @@
+// Code generated by ent, DO NOT EDIT.
+
+package semifinished
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the semifinished type in the database.
+	Label = "semi_finished"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldSn holds the string denoting the sn field in the database.
+	FieldSn = "sn"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldCompletedProcess holds the string denoting the completed_process field in the database.
+	FieldCompletedProcess = "completed_process"
+	// FieldQuantity holds the string denoting the quantity field in the database.
+	FieldQuantity = "quantity"
+	// FieldZoneCode holds the string denoting the zone_code field in the database.
+	FieldZoneCode = "zone_code"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldOrderNo holds the string denoting the order_no field in the database.
+	FieldOrderNo = "order_no"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the semifinished in the database.
+	Table = "semi_finisheds"
+)
+
+// Columns holds all SQL columns for semifinished fields.
+var Columns = []string{
+	FieldID,
+	FieldSn,
+	FieldMaterialCode,
+	FieldCompletedProcess,
+	FieldQuantity,
+	FieldZoneCode,
+	FieldStatus,
+	FieldOrderNo,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultQuantity holds the default value on creation for the "quantity" field.
+	DefaultQuantity int
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the SemiFinished queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// BySn orders the results by the sn field.
+func BySn(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldSn, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByCompletedProcess orders the results by the completed_process field.
+func ByCompletedProcess(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCompletedProcess, opts...).ToFunc()
+}
+
+// ByQuantity orders the results by the quantity field.
+func ByQuantity(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldQuantity, opts...).ToFunc()
+}
+
+// ByZoneCode orders the results by the zone_code field.
+func ByZoneCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldZoneCode, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByOrderNo orders the results by the order_no field.
+func ByOrderNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOrderNo, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/semifinished/where.go b/bj_power_wms/semifinished/where.go
new file mode 100644
index 0000000..5282628
--- /dev/null
+++ b/bj_power_wms/semifinished/where.go
@@ -0,0 +1,664 @@
+// Code generated by ent, DO NOT EDIT.
+
+package semifinished
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldID, id))
+}
+
+// Sn applies equality check predicate on the "sn" field. It's identical to SnEQ.
+func Sn(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldSn, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// CompletedProcess applies equality check predicate on the "completed_process" field. It's identical to CompletedProcessEQ.
+func CompletedProcess(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldCompletedProcess, v))
+}
+
+// Quantity applies equality check predicate on the "quantity" field. It's identical to QuantityEQ.
+func Quantity(v int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldQuantity, v))
+}
+
+// ZoneCode applies equality check predicate on the "zone_code" field. It's identical to ZoneCodeEQ.
+func ZoneCode(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldStatus, v))
+}
+
+// OrderNo applies equality check predicate on the "order_no" field. It's identical to OrderNoEQ.
+func OrderNo(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// SnEQ applies the EQ predicate on the "sn" field.
+func SnEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldSn, v))
+}
+
+// SnNEQ applies the NEQ predicate on the "sn" field.
+func SnNEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldSn, v))
+}
+
+// SnIn applies the In predicate on the "sn" field.
+func SnIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldSn, vs...))
+}
+
+// SnNotIn applies the NotIn predicate on the "sn" field.
+func SnNotIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldSn, vs...))
+}
+
+// SnGT applies the GT predicate on the "sn" field.
+func SnGT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldSn, v))
+}
+
+// SnGTE applies the GTE predicate on the "sn" field.
+func SnGTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldSn, v))
+}
+
+// SnLT applies the LT predicate on the "sn" field.
+func SnLT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldSn, v))
+}
+
+// SnLTE applies the LTE predicate on the "sn" field.
+func SnLTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldSn, v))
+}
+
+// SnContains applies the Contains predicate on the "sn" field.
+func SnContains(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContains(FieldSn, v))
+}
+
+// SnHasPrefix applies the HasPrefix predicate on the "sn" field.
+func SnHasPrefix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasPrefix(FieldSn, v))
+}
+
+// SnHasSuffix applies the HasSuffix predicate on the "sn" field.
+func SnHasSuffix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasSuffix(FieldSn, v))
+}
+
+// SnEqualFold applies the EqualFold predicate on the "sn" field.
+func SnEqualFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEqualFold(FieldSn, v))
+}
+
+// SnContainsFold applies the ContainsFold predicate on the "sn" field.
+func SnContainsFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContainsFold(FieldSn, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeIsNil applies the IsNil predicate on the "material_code" field.
+func MaterialCodeIsNil() predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIsNull(FieldMaterialCode))
+}
+
+// MaterialCodeNotNil applies the NotNil predicate on the "material_code" field.
+func MaterialCodeNotNil() predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotNull(FieldMaterialCode))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// CompletedProcessEQ applies the EQ predicate on the "completed_process" field.
+func CompletedProcessEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldCompletedProcess, v))
+}
+
+// CompletedProcessNEQ applies the NEQ predicate on the "completed_process" field.
+func CompletedProcessNEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldCompletedProcess, v))
+}
+
+// CompletedProcessIn applies the In predicate on the "completed_process" field.
+func CompletedProcessIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldCompletedProcess, vs...))
+}
+
+// CompletedProcessNotIn applies the NotIn predicate on the "completed_process" field.
+func CompletedProcessNotIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldCompletedProcess, vs...))
+}
+
+// CompletedProcessGT applies the GT predicate on the "completed_process" field.
+func CompletedProcessGT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldCompletedProcess, v))
+}
+
+// CompletedProcessGTE applies the GTE predicate on the "completed_process" field.
+func CompletedProcessGTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldCompletedProcess, v))
+}
+
+// CompletedProcessLT applies the LT predicate on the "completed_process" field.
+func CompletedProcessLT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldCompletedProcess, v))
+}
+
+// CompletedProcessLTE applies the LTE predicate on the "completed_process" field.
+func CompletedProcessLTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldCompletedProcess, v))
+}
+
+// CompletedProcessContains applies the Contains predicate on the "completed_process" field.
+func CompletedProcessContains(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContains(FieldCompletedProcess, v))
+}
+
+// CompletedProcessHasPrefix applies the HasPrefix predicate on the "completed_process" field.
+func CompletedProcessHasPrefix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasPrefix(FieldCompletedProcess, v))
+}
+
+// CompletedProcessHasSuffix applies the HasSuffix predicate on the "completed_process" field.
+func CompletedProcessHasSuffix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasSuffix(FieldCompletedProcess, v))
+}
+
+// CompletedProcessIsNil applies the IsNil predicate on the "completed_process" field.
+func CompletedProcessIsNil() predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIsNull(FieldCompletedProcess))
+}
+
+// CompletedProcessNotNil applies the NotNil predicate on the "completed_process" field.
+func CompletedProcessNotNil() predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotNull(FieldCompletedProcess))
+}
+
+// CompletedProcessEqualFold applies the EqualFold predicate on the "completed_process" field.
+func CompletedProcessEqualFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEqualFold(FieldCompletedProcess, v))
+}
+
+// CompletedProcessContainsFold applies the ContainsFold predicate on the "completed_process" field.
+func CompletedProcessContainsFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContainsFold(FieldCompletedProcess, v))
+}
+
+// QuantityEQ applies the EQ predicate on the "quantity" field.
+func QuantityEQ(v int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldQuantity, v))
+}
+
+// QuantityNEQ applies the NEQ predicate on the "quantity" field.
+func QuantityNEQ(v int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldQuantity, v))
+}
+
+// QuantityIn applies the In predicate on the "quantity" field.
+func QuantityIn(vs ...int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldQuantity, vs...))
+}
+
+// QuantityNotIn applies the NotIn predicate on the "quantity" field.
+func QuantityNotIn(vs ...int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldQuantity, vs...))
+}
+
+// QuantityGT applies the GT predicate on the "quantity" field.
+func QuantityGT(v int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldQuantity, v))
+}
+
+// QuantityGTE applies the GTE predicate on the "quantity" field.
+func QuantityGTE(v int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldQuantity, v))
+}
+
+// QuantityLT applies the LT predicate on the "quantity" field.
+func QuantityLT(v int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldQuantity, v))
+}
+
+// QuantityLTE applies the LTE predicate on the "quantity" field.
+func QuantityLTE(v int) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldQuantity, v))
+}
+
+// ZoneCodeEQ applies the EQ predicate on the "zone_code" field.
+func ZoneCodeEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeNEQ applies the NEQ predicate on the "zone_code" field.
+func ZoneCodeNEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeIn applies the In predicate on the "zone_code" field.
+func ZoneCodeIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeNotIn applies the NotIn predicate on the "zone_code" field.
+func ZoneCodeNotIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeGT applies the GT predicate on the "zone_code" field.
+func ZoneCodeGT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldZoneCode, v))
+}
+
+// ZoneCodeGTE applies the GTE predicate on the "zone_code" field.
+func ZoneCodeGTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldZoneCode, v))
+}
+
+// ZoneCodeLT applies the LT predicate on the "zone_code" field.
+func ZoneCodeLT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldZoneCode, v))
+}
+
+// ZoneCodeLTE applies the LTE predicate on the "zone_code" field.
+func ZoneCodeLTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldZoneCode, v))
+}
+
+// ZoneCodeContains applies the Contains predicate on the "zone_code" field.
+func ZoneCodeContains(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContains(FieldZoneCode, v))
+}
+
+// ZoneCodeHasPrefix applies the HasPrefix predicate on the "zone_code" field.
+func ZoneCodeHasPrefix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasPrefix(FieldZoneCode, v))
+}
+
+// ZoneCodeHasSuffix applies the HasSuffix predicate on the "zone_code" field.
+func ZoneCodeHasSuffix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasSuffix(FieldZoneCode, v))
+}
+
+// ZoneCodeIsNil applies the IsNil predicate on the "zone_code" field.
+func ZoneCodeIsNil() predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIsNull(FieldZoneCode))
+}
+
+// ZoneCodeNotNil applies the NotNil predicate on the "zone_code" field.
+func ZoneCodeNotNil() predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotNull(FieldZoneCode))
+}
+
+// ZoneCodeEqualFold applies the EqualFold predicate on the "zone_code" field.
+func ZoneCodeEqualFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEqualFold(FieldZoneCode, v))
+}
+
+// ZoneCodeContainsFold applies the ContainsFold predicate on the "zone_code" field.
+func ZoneCodeContainsFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContainsFold(FieldZoneCode, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// OrderNoEQ applies the EQ predicate on the "order_no" field.
+func OrderNoEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldOrderNo, v))
+}
+
+// OrderNoNEQ applies the NEQ predicate on the "order_no" field.
+func OrderNoNEQ(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldOrderNo, v))
+}
+
+// OrderNoIn applies the In predicate on the "order_no" field.
+func OrderNoIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldOrderNo, vs...))
+}
+
+// OrderNoNotIn applies the NotIn predicate on the "order_no" field.
+func OrderNoNotIn(vs ...string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldOrderNo, vs...))
+}
+
+// OrderNoGT applies the GT predicate on the "order_no" field.
+func OrderNoGT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldOrderNo, v))
+}
+
+// OrderNoGTE applies the GTE predicate on the "order_no" field.
+func OrderNoGTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldOrderNo, v))
+}
+
+// OrderNoLT applies the LT predicate on the "order_no" field.
+func OrderNoLT(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldOrderNo, v))
+}
+
+// OrderNoLTE applies the LTE predicate on the "order_no" field.
+func OrderNoLTE(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldOrderNo, v))
+}
+
+// OrderNoContains applies the Contains predicate on the "order_no" field.
+func OrderNoContains(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContains(FieldOrderNo, v))
+}
+
+// OrderNoHasPrefix applies the HasPrefix predicate on the "order_no" field.
+func OrderNoHasPrefix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasPrefix(FieldOrderNo, v))
+}
+
+// OrderNoHasSuffix applies the HasSuffix predicate on the "order_no" field.
+func OrderNoHasSuffix(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldHasSuffix(FieldOrderNo, v))
+}
+
+// OrderNoIsNil applies the IsNil predicate on the "order_no" field.
+func OrderNoIsNil() predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIsNull(FieldOrderNo))
+}
+
+// OrderNoNotNil applies the NotNil predicate on the "order_no" field.
+func OrderNoNotNil() predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotNull(FieldOrderNo))
+}
+
+// OrderNoEqualFold applies the EqualFold predicate on the "order_no" field.
+func OrderNoEqualFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEqualFold(FieldOrderNo, v))
+}
+
+// OrderNoContainsFold applies the ContainsFold predicate on the "order_no" field.
+func OrderNoContainsFold(v string) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldContainsFold(FieldOrderNo, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.SemiFinished) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.SemiFinished) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.SemiFinished) predicate.SemiFinished {
+	return predicate.SemiFinished(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/stocktakeitem/stocktakeitem.go b/bj_power_wms/stocktakeitem/stocktakeitem.go
new file mode 100644
index 0000000..a8c444d
--- /dev/null
+++ b/bj_power_wms/stocktakeitem/stocktakeitem.go
@@ -0,0 +1,172 @@
+// Code generated by ent, DO NOT EDIT.
+
+package stocktakeitem
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the stocktakeitem type in the database.
+	Label = "stocktake_item"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldStocktakeNo holds the string denoting the stocktake_no field in the database.
+	FieldStocktakeNo = "stocktake_no"
+	// FieldTargetType holds the string denoting the target_type field in the database.
+	FieldTargetType = "target_type"
+	// FieldTargetID holds the string denoting the target_id field in the database.
+	FieldTargetID = "target_id"
+	// FieldMaterialCode holds the string denoting the material_code field in the database.
+	FieldMaterialCode = "material_code"
+	// FieldZoneCode holds the string denoting the zone_code field in the database.
+	FieldZoneCode = "zone_code"
+	// FieldShelfNo holds the string denoting the shelf_no field in the database.
+	FieldShelfNo = "shelf_no"
+	// FieldLayerNo holds the string denoting the layer_no field in the database.
+	FieldLayerNo = "layer_no"
+	// FieldPositionNo holds the string denoting the position_no field in the database.
+	FieldPositionNo = "position_no"
+	// FieldBookQty holds the string denoting the book_qty field in the database.
+	FieldBookQty = "book_qty"
+	// FieldScannedQty holds the string denoting the scanned_qty field in the database.
+	FieldScannedQty = "scanned_qty"
+	// FieldDiffQty holds the string denoting the diff_qty field in the database.
+	FieldDiffQty = "diff_qty"
+	// FieldCounted holds the string denoting the counted field in the database.
+	FieldCounted = "counted"
+	// FieldCountedBy holds the string denoting the counted_by field in the database.
+	FieldCountedBy = "counted_by"
+	// FieldCountedAt holds the string denoting the counted_at field in the database.
+	FieldCountedAt = "counted_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the stocktakeitem in the database.
+	Table = "stocktake_items"
+)
+
+// Columns holds all SQL columns for stocktakeitem fields.
+var Columns = []string{
+	FieldID,
+	FieldStocktakeNo,
+	FieldTargetType,
+	FieldTargetID,
+	FieldMaterialCode,
+	FieldZoneCode,
+	FieldShelfNo,
+	FieldLayerNo,
+	FieldPositionNo,
+	FieldBookQty,
+	FieldScannedQty,
+	FieldDiffQty,
+	FieldCounted,
+	FieldCountedBy,
+	FieldCountedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultBookQty holds the default value on creation for the "book_qty" field.
+	DefaultBookQty int
+	// DefaultScannedQty holds the default value on creation for the "scanned_qty" field.
+	DefaultScannedQty int
+	// DefaultDiffQty holds the default value on creation for the "diff_qty" field.
+	DefaultDiffQty int
+	// DefaultCounted holds the default value on creation for the "counted" field.
+	DefaultCounted bool
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the StocktakeItem queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByStocktakeNo orders the results by the stocktake_no field.
+func ByStocktakeNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStocktakeNo, opts...).ToFunc()
+}
+
+// ByTargetType orders the results by the target_type field.
+func ByTargetType(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetType, opts...).ToFunc()
+}
+
+// ByTargetID orders the results by the target_id field.
+func ByTargetID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTargetID, opts...).ToFunc()
+}
+
+// ByMaterialCode orders the results by the material_code field.
+func ByMaterialCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldMaterialCode, opts...).ToFunc()
+}
+
+// ByZoneCode orders the results by the zone_code field.
+func ByZoneCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldZoneCode, opts...).ToFunc()
+}
+
+// ByShelfNo orders the results by the shelf_no field.
+func ByShelfNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldShelfNo, opts...).ToFunc()
+}
+
+// ByLayerNo orders the results by the layer_no field.
+func ByLayerNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLayerNo, opts...).ToFunc()
+}
+
+// ByPositionNo orders the results by the position_no field.
+func ByPositionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPositionNo, opts...).ToFunc()
+}
+
+// ByBookQty orders the results by the book_qty field.
+func ByBookQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldBookQty, opts...).ToFunc()
+}
+
+// ByScannedQty orders the results by the scanned_qty field.
+func ByScannedQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldScannedQty, opts...).ToFunc()
+}
+
+// ByDiffQty orders the results by the diff_qty field.
+func ByDiffQty(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDiffQty, opts...).ToFunc()
+}
+
+// ByCounted orders the results by the counted field.
+func ByCounted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCounted, opts...).ToFunc()
+}
+
+// ByCountedBy orders the results by the counted_by field.
+func ByCountedBy(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCountedBy, opts...).ToFunc()
+}
+
+// ByCountedAt orders the results by the counted_at field.
+func ByCountedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCountedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/stocktakeitem/where.go b/bj_power_wms/stocktakeitem/where.go
new file mode 100644
index 0000000..aec164f
--- /dev/null
+++ b/bj_power_wms/stocktakeitem/where.go
@@ -0,0 +1,1009 @@
+// Code generated by ent, DO NOT EDIT.
+
+package stocktakeitem
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldID, id))
+}
+
+// StocktakeNo applies equality check predicate on the "stocktake_no" field. It's identical to StocktakeNoEQ.
+func StocktakeNo(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldStocktakeNo, v))
+}
+
+// TargetType applies equality check predicate on the "target_type" field. It's identical to TargetTypeEQ.
+func TargetType(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldTargetType, v))
+}
+
+// TargetID applies equality check predicate on the "target_id" field. It's identical to TargetIDEQ.
+func TargetID(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldTargetID, v))
+}
+
+// MaterialCode applies equality check predicate on the "material_code" field. It's identical to MaterialCodeEQ.
+func MaterialCode(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// ZoneCode applies equality check predicate on the "zone_code" field. It's identical to ZoneCodeEQ.
+func ZoneCode(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ShelfNo applies equality check predicate on the "shelf_no" field. It's identical to ShelfNoEQ.
+func ShelfNo(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// LayerNo applies equality check predicate on the "layer_no" field. It's identical to LayerNoEQ.
+func LayerNo(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// PositionNo applies equality check predicate on the "position_no" field. It's identical to PositionNoEQ.
+func PositionNo(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// BookQty applies equality check predicate on the "book_qty" field. It's identical to BookQtyEQ.
+func BookQty(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldBookQty, v))
+}
+
+// ScannedQty applies equality check predicate on the "scanned_qty" field. It's identical to ScannedQtyEQ.
+func ScannedQty(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldScannedQty, v))
+}
+
+// DiffQty applies equality check predicate on the "diff_qty" field. It's identical to DiffQtyEQ.
+func DiffQty(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldDiffQty, v))
+}
+
+// Counted applies equality check predicate on the "counted" field. It's identical to CountedEQ.
+func Counted(v bool) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldCounted, v))
+}
+
+// CountedBy applies equality check predicate on the "counted_by" field. It's identical to CountedByEQ.
+func CountedBy(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldCountedBy, v))
+}
+
+// CountedAt applies equality check predicate on the "counted_at" field. It's identical to CountedAtEQ.
+func CountedAt(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldCountedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// StocktakeNoEQ applies the EQ predicate on the "stocktake_no" field.
+func StocktakeNoEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldStocktakeNo, v))
+}
+
+// StocktakeNoNEQ applies the NEQ predicate on the "stocktake_no" field.
+func StocktakeNoNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldStocktakeNo, v))
+}
+
+// StocktakeNoIn applies the In predicate on the "stocktake_no" field.
+func StocktakeNoIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldStocktakeNo, vs...))
+}
+
+// StocktakeNoNotIn applies the NotIn predicate on the "stocktake_no" field.
+func StocktakeNoNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldStocktakeNo, vs...))
+}
+
+// StocktakeNoGT applies the GT predicate on the "stocktake_no" field.
+func StocktakeNoGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldStocktakeNo, v))
+}
+
+// StocktakeNoGTE applies the GTE predicate on the "stocktake_no" field.
+func StocktakeNoGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldStocktakeNo, v))
+}
+
+// StocktakeNoLT applies the LT predicate on the "stocktake_no" field.
+func StocktakeNoLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldStocktakeNo, v))
+}
+
+// StocktakeNoLTE applies the LTE predicate on the "stocktake_no" field.
+func StocktakeNoLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldStocktakeNo, v))
+}
+
+// StocktakeNoContains applies the Contains predicate on the "stocktake_no" field.
+func StocktakeNoContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldStocktakeNo, v))
+}
+
+// StocktakeNoHasPrefix applies the HasPrefix predicate on the "stocktake_no" field.
+func StocktakeNoHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldStocktakeNo, v))
+}
+
+// StocktakeNoHasSuffix applies the HasSuffix predicate on the "stocktake_no" field.
+func StocktakeNoHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldStocktakeNo, v))
+}
+
+// StocktakeNoEqualFold applies the EqualFold predicate on the "stocktake_no" field.
+func StocktakeNoEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldStocktakeNo, v))
+}
+
+// StocktakeNoContainsFold applies the ContainsFold predicate on the "stocktake_no" field.
+func StocktakeNoContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldStocktakeNo, v))
+}
+
+// TargetTypeEQ applies the EQ predicate on the "target_type" field.
+func TargetTypeEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldTargetType, v))
+}
+
+// TargetTypeNEQ applies the NEQ predicate on the "target_type" field.
+func TargetTypeNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldTargetType, v))
+}
+
+// TargetTypeIn applies the In predicate on the "target_type" field.
+func TargetTypeIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldTargetType, vs...))
+}
+
+// TargetTypeNotIn applies the NotIn predicate on the "target_type" field.
+func TargetTypeNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldTargetType, vs...))
+}
+
+// TargetTypeGT applies the GT predicate on the "target_type" field.
+func TargetTypeGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldTargetType, v))
+}
+
+// TargetTypeGTE applies the GTE predicate on the "target_type" field.
+func TargetTypeGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldTargetType, v))
+}
+
+// TargetTypeLT applies the LT predicate on the "target_type" field.
+func TargetTypeLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldTargetType, v))
+}
+
+// TargetTypeLTE applies the LTE predicate on the "target_type" field.
+func TargetTypeLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldTargetType, v))
+}
+
+// TargetTypeContains applies the Contains predicate on the "target_type" field.
+func TargetTypeContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldTargetType, v))
+}
+
+// TargetTypeHasPrefix applies the HasPrefix predicate on the "target_type" field.
+func TargetTypeHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldTargetType, v))
+}
+
+// TargetTypeHasSuffix applies the HasSuffix predicate on the "target_type" field.
+func TargetTypeHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldTargetType, v))
+}
+
+// TargetTypeEqualFold applies the EqualFold predicate on the "target_type" field.
+func TargetTypeEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldTargetType, v))
+}
+
+// TargetTypeContainsFold applies the ContainsFold predicate on the "target_type" field.
+func TargetTypeContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldTargetType, v))
+}
+
+// TargetIDEQ applies the EQ predicate on the "target_id" field.
+func TargetIDEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldTargetID, v))
+}
+
+// TargetIDNEQ applies the NEQ predicate on the "target_id" field.
+func TargetIDNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldTargetID, v))
+}
+
+// TargetIDIn applies the In predicate on the "target_id" field.
+func TargetIDIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldTargetID, vs...))
+}
+
+// TargetIDNotIn applies the NotIn predicate on the "target_id" field.
+func TargetIDNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldTargetID, vs...))
+}
+
+// TargetIDGT applies the GT predicate on the "target_id" field.
+func TargetIDGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldTargetID, v))
+}
+
+// TargetIDGTE applies the GTE predicate on the "target_id" field.
+func TargetIDGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldTargetID, v))
+}
+
+// TargetIDLT applies the LT predicate on the "target_id" field.
+func TargetIDLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldTargetID, v))
+}
+
+// TargetIDLTE applies the LTE predicate on the "target_id" field.
+func TargetIDLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldTargetID, v))
+}
+
+// TargetIDContains applies the Contains predicate on the "target_id" field.
+func TargetIDContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldTargetID, v))
+}
+
+// TargetIDHasPrefix applies the HasPrefix predicate on the "target_id" field.
+func TargetIDHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldTargetID, v))
+}
+
+// TargetIDHasSuffix applies the HasSuffix predicate on the "target_id" field.
+func TargetIDHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldTargetID, v))
+}
+
+// TargetIDEqualFold applies the EqualFold predicate on the "target_id" field.
+func TargetIDEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldTargetID, v))
+}
+
+// TargetIDContainsFold applies the ContainsFold predicate on the "target_id" field.
+func TargetIDContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldTargetID, v))
+}
+
+// MaterialCodeEQ applies the EQ predicate on the "material_code" field.
+func MaterialCodeEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeNEQ applies the NEQ predicate on the "material_code" field.
+func MaterialCodeNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldMaterialCode, v))
+}
+
+// MaterialCodeIn applies the In predicate on the "material_code" field.
+func MaterialCodeIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeNotIn applies the NotIn predicate on the "material_code" field.
+func MaterialCodeNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldMaterialCode, vs...))
+}
+
+// MaterialCodeGT applies the GT predicate on the "material_code" field.
+func MaterialCodeGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldMaterialCode, v))
+}
+
+// MaterialCodeGTE applies the GTE predicate on the "material_code" field.
+func MaterialCodeGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeLT applies the LT predicate on the "material_code" field.
+func MaterialCodeLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldMaterialCode, v))
+}
+
+// MaterialCodeLTE applies the LTE predicate on the "material_code" field.
+func MaterialCodeLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldMaterialCode, v))
+}
+
+// MaterialCodeContains applies the Contains predicate on the "material_code" field.
+func MaterialCodeContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasPrefix applies the HasPrefix predicate on the "material_code" field.
+func MaterialCodeHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldMaterialCode, v))
+}
+
+// MaterialCodeHasSuffix applies the HasSuffix predicate on the "material_code" field.
+func MaterialCodeHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldMaterialCode, v))
+}
+
+// MaterialCodeIsNil applies the IsNil predicate on the "material_code" field.
+func MaterialCodeIsNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIsNull(FieldMaterialCode))
+}
+
+// MaterialCodeNotNil applies the NotNil predicate on the "material_code" field.
+func MaterialCodeNotNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotNull(FieldMaterialCode))
+}
+
+// MaterialCodeEqualFold applies the EqualFold predicate on the "material_code" field.
+func MaterialCodeEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldMaterialCode, v))
+}
+
+// MaterialCodeContainsFold applies the ContainsFold predicate on the "material_code" field.
+func MaterialCodeContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldMaterialCode, v))
+}
+
+// ZoneCodeEQ applies the EQ predicate on the "zone_code" field.
+func ZoneCodeEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeNEQ applies the NEQ predicate on the "zone_code" field.
+func ZoneCodeNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeIn applies the In predicate on the "zone_code" field.
+func ZoneCodeIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeNotIn applies the NotIn predicate on the "zone_code" field.
+func ZoneCodeNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeGT applies the GT predicate on the "zone_code" field.
+func ZoneCodeGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldZoneCode, v))
+}
+
+// ZoneCodeGTE applies the GTE predicate on the "zone_code" field.
+func ZoneCodeGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldZoneCode, v))
+}
+
+// ZoneCodeLT applies the LT predicate on the "zone_code" field.
+func ZoneCodeLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldZoneCode, v))
+}
+
+// ZoneCodeLTE applies the LTE predicate on the "zone_code" field.
+func ZoneCodeLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldZoneCode, v))
+}
+
+// ZoneCodeContains applies the Contains predicate on the "zone_code" field.
+func ZoneCodeContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldZoneCode, v))
+}
+
+// ZoneCodeHasPrefix applies the HasPrefix predicate on the "zone_code" field.
+func ZoneCodeHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldZoneCode, v))
+}
+
+// ZoneCodeHasSuffix applies the HasSuffix predicate on the "zone_code" field.
+func ZoneCodeHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldZoneCode, v))
+}
+
+// ZoneCodeIsNil applies the IsNil predicate on the "zone_code" field.
+func ZoneCodeIsNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIsNull(FieldZoneCode))
+}
+
+// ZoneCodeNotNil applies the NotNil predicate on the "zone_code" field.
+func ZoneCodeNotNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotNull(FieldZoneCode))
+}
+
+// ZoneCodeEqualFold applies the EqualFold predicate on the "zone_code" field.
+func ZoneCodeEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldZoneCode, v))
+}
+
+// ZoneCodeContainsFold applies the ContainsFold predicate on the "zone_code" field.
+func ZoneCodeContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldZoneCode, v))
+}
+
+// ShelfNoEQ applies the EQ predicate on the "shelf_no" field.
+func ShelfNoEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// ShelfNoNEQ applies the NEQ predicate on the "shelf_no" field.
+func ShelfNoNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldShelfNo, v))
+}
+
+// ShelfNoIn applies the In predicate on the "shelf_no" field.
+func ShelfNoIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoNotIn applies the NotIn predicate on the "shelf_no" field.
+func ShelfNoNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoGT applies the GT predicate on the "shelf_no" field.
+func ShelfNoGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldShelfNo, v))
+}
+
+// ShelfNoGTE applies the GTE predicate on the "shelf_no" field.
+func ShelfNoGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldShelfNo, v))
+}
+
+// ShelfNoLT applies the LT predicate on the "shelf_no" field.
+func ShelfNoLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldShelfNo, v))
+}
+
+// ShelfNoLTE applies the LTE predicate on the "shelf_no" field.
+func ShelfNoLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldShelfNo, v))
+}
+
+// ShelfNoContains applies the Contains predicate on the "shelf_no" field.
+func ShelfNoContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldShelfNo, v))
+}
+
+// ShelfNoHasPrefix applies the HasPrefix predicate on the "shelf_no" field.
+func ShelfNoHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldShelfNo, v))
+}
+
+// ShelfNoHasSuffix applies the HasSuffix predicate on the "shelf_no" field.
+func ShelfNoHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldShelfNo, v))
+}
+
+// ShelfNoIsNil applies the IsNil predicate on the "shelf_no" field.
+func ShelfNoIsNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIsNull(FieldShelfNo))
+}
+
+// ShelfNoNotNil applies the NotNil predicate on the "shelf_no" field.
+func ShelfNoNotNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotNull(FieldShelfNo))
+}
+
+// ShelfNoEqualFold applies the EqualFold predicate on the "shelf_no" field.
+func ShelfNoEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldShelfNo, v))
+}
+
+// ShelfNoContainsFold applies the ContainsFold predicate on the "shelf_no" field.
+func ShelfNoContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldShelfNo, v))
+}
+
+// LayerNoEQ applies the EQ predicate on the "layer_no" field.
+func LayerNoEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// LayerNoNEQ applies the NEQ predicate on the "layer_no" field.
+func LayerNoNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldLayerNo, v))
+}
+
+// LayerNoIn applies the In predicate on the "layer_no" field.
+func LayerNoIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldLayerNo, vs...))
+}
+
+// LayerNoNotIn applies the NotIn predicate on the "layer_no" field.
+func LayerNoNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldLayerNo, vs...))
+}
+
+// LayerNoGT applies the GT predicate on the "layer_no" field.
+func LayerNoGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldLayerNo, v))
+}
+
+// LayerNoGTE applies the GTE predicate on the "layer_no" field.
+func LayerNoGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldLayerNo, v))
+}
+
+// LayerNoLT applies the LT predicate on the "layer_no" field.
+func LayerNoLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldLayerNo, v))
+}
+
+// LayerNoLTE applies the LTE predicate on the "layer_no" field.
+func LayerNoLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldLayerNo, v))
+}
+
+// LayerNoContains applies the Contains predicate on the "layer_no" field.
+func LayerNoContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldLayerNo, v))
+}
+
+// LayerNoHasPrefix applies the HasPrefix predicate on the "layer_no" field.
+func LayerNoHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldLayerNo, v))
+}
+
+// LayerNoHasSuffix applies the HasSuffix predicate on the "layer_no" field.
+func LayerNoHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldLayerNo, v))
+}
+
+// LayerNoIsNil applies the IsNil predicate on the "layer_no" field.
+func LayerNoIsNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIsNull(FieldLayerNo))
+}
+
+// LayerNoNotNil applies the NotNil predicate on the "layer_no" field.
+func LayerNoNotNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotNull(FieldLayerNo))
+}
+
+// LayerNoEqualFold applies the EqualFold predicate on the "layer_no" field.
+func LayerNoEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldLayerNo, v))
+}
+
+// LayerNoContainsFold applies the ContainsFold predicate on the "layer_no" field.
+func LayerNoContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldLayerNo, v))
+}
+
+// PositionNoEQ applies the EQ predicate on the "position_no" field.
+func PositionNoEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// PositionNoNEQ applies the NEQ predicate on the "position_no" field.
+func PositionNoNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldPositionNo, v))
+}
+
+// PositionNoIn applies the In predicate on the "position_no" field.
+func PositionNoIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldPositionNo, vs...))
+}
+
+// PositionNoNotIn applies the NotIn predicate on the "position_no" field.
+func PositionNoNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldPositionNo, vs...))
+}
+
+// PositionNoGT applies the GT predicate on the "position_no" field.
+func PositionNoGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldPositionNo, v))
+}
+
+// PositionNoGTE applies the GTE predicate on the "position_no" field.
+func PositionNoGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldPositionNo, v))
+}
+
+// PositionNoLT applies the LT predicate on the "position_no" field.
+func PositionNoLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldPositionNo, v))
+}
+
+// PositionNoLTE applies the LTE predicate on the "position_no" field.
+func PositionNoLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldPositionNo, v))
+}
+
+// PositionNoContains applies the Contains predicate on the "position_no" field.
+func PositionNoContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldPositionNo, v))
+}
+
+// PositionNoHasPrefix applies the HasPrefix predicate on the "position_no" field.
+func PositionNoHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldPositionNo, v))
+}
+
+// PositionNoHasSuffix applies the HasSuffix predicate on the "position_no" field.
+func PositionNoHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldPositionNo, v))
+}
+
+// PositionNoIsNil applies the IsNil predicate on the "position_no" field.
+func PositionNoIsNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIsNull(FieldPositionNo))
+}
+
+// PositionNoNotNil applies the NotNil predicate on the "position_no" field.
+func PositionNoNotNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotNull(FieldPositionNo))
+}
+
+// PositionNoEqualFold applies the EqualFold predicate on the "position_no" field.
+func PositionNoEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldPositionNo, v))
+}
+
+// PositionNoContainsFold applies the ContainsFold predicate on the "position_no" field.
+func PositionNoContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldPositionNo, v))
+}
+
+// BookQtyEQ applies the EQ predicate on the "book_qty" field.
+func BookQtyEQ(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldBookQty, v))
+}
+
+// BookQtyNEQ applies the NEQ predicate on the "book_qty" field.
+func BookQtyNEQ(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldBookQty, v))
+}
+
+// BookQtyIn applies the In predicate on the "book_qty" field.
+func BookQtyIn(vs ...int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldBookQty, vs...))
+}
+
+// BookQtyNotIn applies the NotIn predicate on the "book_qty" field.
+func BookQtyNotIn(vs ...int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldBookQty, vs...))
+}
+
+// BookQtyGT applies the GT predicate on the "book_qty" field.
+func BookQtyGT(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldBookQty, v))
+}
+
+// BookQtyGTE applies the GTE predicate on the "book_qty" field.
+func BookQtyGTE(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldBookQty, v))
+}
+
+// BookQtyLT applies the LT predicate on the "book_qty" field.
+func BookQtyLT(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldBookQty, v))
+}
+
+// BookQtyLTE applies the LTE predicate on the "book_qty" field.
+func BookQtyLTE(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldBookQty, v))
+}
+
+// ScannedQtyEQ applies the EQ predicate on the "scanned_qty" field.
+func ScannedQtyEQ(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldScannedQty, v))
+}
+
+// ScannedQtyNEQ applies the NEQ predicate on the "scanned_qty" field.
+func ScannedQtyNEQ(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldScannedQty, v))
+}
+
+// ScannedQtyIn applies the In predicate on the "scanned_qty" field.
+func ScannedQtyIn(vs ...int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldScannedQty, vs...))
+}
+
+// ScannedQtyNotIn applies the NotIn predicate on the "scanned_qty" field.
+func ScannedQtyNotIn(vs ...int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldScannedQty, vs...))
+}
+
+// ScannedQtyGT applies the GT predicate on the "scanned_qty" field.
+func ScannedQtyGT(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldScannedQty, v))
+}
+
+// ScannedQtyGTE applies the GTE predicate on the "scanned_qty" field.
+func ScannedQtyGTE(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldScannedQty, v))
+}
+
+// ScannedQtyLT applies the LT predicate on the "scanned_qty" field.
+func ScannedQtyLT(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldScannedQty, v))
+}
+
+// ScannedQtyLTE applies the LTE predicate on the "scanned_qty" field.
+func ScannedQtyLTE(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldScannedQty, v))
+}
+
+// DiffQtyEQ applies the EQ predicate on the "diff_qty" field.
+func DiffQtyEQ(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldDiffQty, v))
+}
+
+// DiffQtyNEQ applies the NEQ predicate on the "diff_qty" field.
+func DiffQtyNEQ(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldDiffQty, v))
+}
+
+// DiffQtyIn applies the In predicate on the "diff_qty" field.
+func DiffQtyIn(vs ...int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldDiffQty, vs...))
+}
+
+// DiffQtyNotIn applies the NotIn predicate on the "diff_qty" field.
+func DiffQtyNotIn(vs ...int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldDiffQty, vs...))
+}
+
+// DiffQtyGT applies the GT predicate on the "diff_qty" field.
+func DiffQtyGT(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldDiffQty, v))
+}
+
+// DiffQtyGTE applies the GTE predicate on the "diff_qty" field.
+func DiffQtyGTE(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldDiffQty, v))
+}
+
+// DiffQtyLT applies the LT predicate on the "diff_qty" field.
+func DiffQtyLT(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldDiffQty, v))
+}
+
+// DiffQtyLTE applies the LTE predicate on the "diff_qty" field.
+func DiffQtyLTE(v int) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldDiffQty, v))
+}
+
+// CountedEQ applies the EQ predicate on the "counted" field.
+func CountedEQ(v bool) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldCounted, v))
+}
+
+// CountedNEQ applies the NEQ predicate on the "counted" field.
+func CountedNEQ(v bool) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldCounted, v))
+}
+
+// CountedByEQ applies the EQ predicate on the "counted_by" field.
+func CountedByEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldCountedBy, v))
+}
+
+// CountedByNEQ applies the NEQ predicate on the "counted_by" field.
+func CountedByNEQ(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldCountedBy, v))
+}
+
+// CountedByIn applies the In predicate on the "counted_by" field.
+func CountedByIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldCountedBy, vs...))
+}
+
+// CountedByNotIn applies the NotIn predicate on the "counted_by" field.
+func CountedByNotIn(vs ...string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldCountedBy, vs...))
+}
+
+// CountedByGT applies the GT predicate on the "counted_by" field.
+func CountedByGT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldCountedBy, v))
+}
+
+// CountedByGTE applies the GTE predicate on the "counted_by" field.
+func CountedByGTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldCountedBy, v))
+}
+
+// CountedByLT applies the LT predicate on the "counted_by" field.
+func CountedByLT(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldCountedBy, v))
+}
+
+// CountedByLTE applies the LTE predicate on the "counted_by" field.
+func CountedByLTE(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldCountedBy, v))
+}
+
+// CountedByContains applies the Contains predicate on the "counted_by" field.
+func CountedByContains(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContains(FieldCountedBy, v))
+}
+
+// CountedByHasPrefix applies the HasPrefix predicate on the "counted_by" field.
+func CountedByHasPrefix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasPrefix(FieldCountedBy, v))
+}
+
+// CountedByHasSuffix applies the HasSuffix predicate on the "counted_by" field.
+func CountedByHasSuffix(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldHasSuffix(FieldCountedBy, v))
+}
+
+// CountedByIsNil applies the IsNil predicate on the "counted_by" field.
+func CountedByIsNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIsNull(FieldCountedBy))
+}
+
+// CountedByNotNil applies the NotNil predicate on the "counted_by" field.
+func CountedByNotNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotNull(FieldCountedBy))
+}
+
+// CountedByEqualFold applies the EqualFold predicate on the "counted_by" field.
+func CountedByEqualFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEqualFold(FieldCountedBy, v))
+}
+
+// CountedByContainsFold applies the ContainsFold predicate on the "counted_by" field.
+func CountedByContainsFold(v string) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldContainsFold(FieldCountedBy, v))
+}
+
+// CountedAtEQ applies the EQ predicate on the "counted_at" field.
+func CountedAtEQ(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldCountedAt, v))
+}
+
+// CountedAtNEQ applies the NEQ predicate on the "counted_at" field.
+func CountedAtNEQ(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldCountedAt, v))
+}
+
+// CountedAtIn applies the In predicate on the "counted_at" field.
+func CountedAtIn(vs ...int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldCountedAt, vs...))
+}
+
+// CountedAtNotIn applies the NotIn predicate on the "counted_at" field.
+func CountedAtNotIn(vs ...int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldCountedAt, vs...))
+}
+
+// CountedAtGT applies the GT predicate on the "counted_at" field.
+func CountedAtGT(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldCountedAt, v))
+}
+
+// CountedAtGTE applies the GTE predicate on the "counted_at" field.
+func CountedAtGTE(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldCountedAt, v))
+}
+
+// CountedAtLT applies the LT predicate on the "counted_at" field.
+func CountedAtLT(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldCountedAt, v))
+}
+
+// CountedAtLTE applies the LTE predicate on the "counted_at" field.
+func CountedAtLTE(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldCountedAt, v))
+}
+
+// CountedAtIsNil applies the IsNil predicate on the "counted_at" field.
+func CountedAtIsNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIsNull(FieldCountedAt))
+}
+
+// CountedAtNotNil applies the NotNil predicate on the "counted_at" field.
+func CountedAtNotNil() predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotNull(FieldCountedAt))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.StocktakeItem) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.StocktakeItem) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.StocktakeItem) predicate.StocktakeItem {
+	return predicate.StocktakeItem(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/stocktakeorder/stocktakeorder.go b/bj_power_wms/stocktakeorder/stocktakeorder.go
new file mode 100644
index 0000000..7e32fac
--- /dev/null
+++ b/bj_power_wms/stocktakeorder/stocktakeorder.go
@@ -0,0 +1,156 @@
+// Code generated by ent, DO NOT EDIT.
+
+package stocktakeorder
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the stocktakeorder type in the database.
+	Label = "stocktake_order"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldStocktakeNo holds the string denoting the stocktake_no field in the database.
+	FieldStocktakeNo = "stocktake_no"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldOperator holds the string denoting the operator field in the database.
+	FieldOperator = "operator"
+	// FieldTotalTargets holds the string denoting the total_targets field in the database.
+	FieldTotalTargets = "total_targets"
+	// FieldDiffCount holds the string denoting the diff_count field in the database.
+	FieldDiffCount = "diff_count"
+	// FieldAdjusted holds the string denoting the adjusted field in the database.
+	FieldAdjusted = "adjusted"
+	// FieldAdjustNo holds the string denoting the adjust_no field in the database.
+	FieldAdjustNo = "adjust_no"
+	// FieldWrittenAt holds the string denoting the written_at field in the database.
+	FieldWrittenAt = "written_at"
+	// FieldWrittenBy holds the string denoting the written_by field in the database.
+	FieldWrittenBy = "written_by"
+	// FieldUncountedMode holds the string denoting the uncounted_mode field in the database.
+	FieldUncountedMode = "uncounted_mode"
+	// FieldCancelReason holds the string denoting the cancel_reason field in the database.
+	FieldCancelReason = "cancel_reason"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldFinishedAt holds the string denoting the finished_at field in the database.
+	FieldFinishedAt = "finished_at"
+	// Table holds the table name of the stocktakeorder in the database.
+	Table = "stocktake_orders"
+)
+
+// Columns holds all SQL columns for stocktakeorder fields.
+var Columns = []string{
+	FieldID,
+	FieldStocktakeNo,
+	FieldStatus,
+	FieldOperator,
+	FieldTotalTargets,
+	FieldDiffCount,
+	FieldAdjusted,
+	FieldAdjustNo,
+	FieldWrittenAt,
+	FieldWrittenBy,
+	FieldUncountedMode,
+	FieldCancelReason,
+	FieldCreatedAt,
+	FieldFinishedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultTotalTargets holds the default value on creation for the "total_targets" field.
+	DefaultTotalTargets int
+	// DefaultDiffCount holds the default value on creation for the "diff_count" field.
+	DefaultDiffCount int
+	// DefaultAdjusted holds the default value on creation for the "adjusted" field.
+	DefaultAdjusted bool
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the StocktakeOrder queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByStocktakeNo orders the results by the stocktake_no field.
+func ByStocktakeNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStocktakeNo, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByOperator orders the results by the operator field.
+func ByOperator(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldOperator, opts...).ToFunc()
+}
+
+// ByTotalTargets orders the results by the total_targets field.
+func ByTotalTargets(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldTotalTargets, opts...).ToFunc()
+}
+
+// ByDiffCount orders the results by the diff_count field.
+func ByDiffCount(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDiffCount, opts...).ToFunc()
+}
+
+// ByAdjusted orders the results by the adjusted field.
+func ByAdjusted(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAdjusted, opts...).ToFunc()
+}
+
+// ByAdjustNo orders the results by the adjust_no field.
+func ByAdjustNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldAdjustNo, opts...).ToFunc()
+}
+
+// ByWrittenAt orders the results by the written_at field.
+func ByWrittenAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldWrittenAt, opts...).ToFunc()
+}
+
+// ByWrittenBy orders the results by the written_by field.
+func ByWrittenBy(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldWrittenBy, opts...).ToFunc()
+}
+
+// ByUncountedMode orders the results by the uncounted_mode field.
+func ByUncountedMode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUncountedMode, opts...).ToFunc()
+}
+
+// ByCancelReason orders the results by the cancel_reason field.
+func ByCancelReason(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCancelReason, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByFinishedAt orders the results by the finished_at field.
+func ByFinishedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldFinishedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/stocktakeorder/where.go b/bj_power_wms/stocktakeorder/where.go
new file mode 100644
index 0000000..987fcf7
--- /dev/null
+++ b/bj_power_wms/stocktakeorder/where.go
@@ -0,0 +1,869 @@
+// Code generated by ent, DO NOT EDIT.
+
+package stocktakeorder
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldID, id))
+}
+
+// StocktakeNo applies equality check predicate on the "stocktake_no" field. It's identical to StocktakeNoEQ.
+func StocktakeNo(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldStocktakeNo, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldStatus, v))
+}
+
+// Operator applies equality check predicate on the "operator" field. It's identical to OperatorEQ.
+func Operator(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldOperator, v))
+}
+
+// TotalTargets applies equality check predicate on the "total_targets" field. It's identical to TotalTargetsEQ.
+func TotalTargets(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldTotalTargets, v))
+}
+
+// DiffCount applies equality check predicate on the "diff_count" field. It's identical to DiffCountEQ.
+func DiffCount(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldDiffCount, v))
+}
+
+// Adjusted applies equality check predicate on the "adjusted" field. It's identical to AdjustedEQ.
+func Adjusted(v bool) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldAdjusted, v))
+}
+
+// AdjustNo applies equality check predicate on the "adjust_no" field. It's identical to AdjustNoEQ.
+func AdjustNo(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldAdjustNo, v))
+}
+
+// WrittenAt applies equality check predicate on the "written_at" field. It's identical to WrittenAtEQ.
+func WrittenAt(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldWrittenAt, v))
+}
+
+// WrittenBy applies equality check predicate on the "written_by" field. It's identical to WrittenByEQ.
+func WrittenBy(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldWrittenBy, v))
+}
+
+// UncountedMode applies equality check predicate on the "uncounted_mode" field. It's identical to UncountedModeEQ.
+func UncountedMode(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldUncountedMode, v))
+}
+
+// CancelReason applies equality check predicate on the "cancel_reason" field. It's identical to CancelReasonEQ.
+func CancelReason(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldCancelReason, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// FinishedAt applies equality check predicate on the "finished_at" field. It's identical to FinishedAtEQ.
+func FinishedAt(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldFinishedAt, v))
+}
+
+// StocktakeNoEQ applies the EQ predicate on the "stocktake_no" field.
+func StocktakeNoEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldStocktakeNo, v))
+}
+
+// StocktakeNoNEQ applies the NEQ predicate on the "stocktake_no" field.
+func StocktakeNoNEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldStocktakeNo, v))
+}
+
+// StocktakeNoIn applies the In predicate on the "stocktake_no" field.
+func StocktakeNoIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldStocktakeNo, vs...))
+}
+
+// StocktakeNoNotIn applies the NotIn predicate on the "stocktake_no" field.
+func StocktakeNoNotIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldStocktakeNo, vs...))
+}
+
+// StocktakeNoGT applies the GT predicate on the "stocktake_no" field.
+func StocktakeNoGT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldStocktakeNo, v))
+}
+
+// StocktakeNoGTE applies the GTE predicate on the "stocktake_no" field.
+func StocktakeNoGTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldStocktakeNo, v))
+}
+
+// StocktakeNoLT applies the LT predicate on the "stocktake_no" field.
+func StocktakeNoLT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldStocktakeNo, v))
+}
+
+// StocktakeNoLTE applies the LTE predicate on the "stocktake_no" field.
+func StocktakeNoLTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldStocktakeNo, v))
+}
+
+// StocktakeNoContains applies the Contains predicate on the "stocktake_no" field.
+func StocktakeNoContains(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContains(FieldStocktakeNo, v))
+}
+
+// StocktakeNoHasPrefix applies the HasPrefix predicate on the "stocktake_no" field.
+func StocktakeNoHasPrefix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasPrefix(FieldStocktakeNo, v))
+}
+
+// StocktakeNoHasSuffix applies the HasSuffix predicate on the "stocktake_no" field.
+func StocktakeNoHasSuffix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasSuffix(FieldStocktakeNo, v))
+}
+
+// StocktakeNoEqualFold applies the EqualFold predicate on the "stocktake_no" field.
+func StocktakeNoEqualFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEqualFold(FieldStocktakeNo, v))
+}
+
+// StocktakeNoContainsFold applies the ContainsFold predicate on the "stocktake_no" field.
+func StocktakeNoContainsFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContainsFold(FieldStocktakeNo, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// OperatorEQ applies the EQ predicate on the "operator" field.
+func OperatorEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldOperator, v))
+}
+
+// OperatorNEQ applies the NEQ predicate on the "operator" field.
+func OperatorNEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldOperator, v))
+}
+
+// OperatorIn applies the In predicate on the "operator" field.
+func OperatorIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldOperator, vs...))
+}
+
+// OperatorNotIn applies the NotIn predicate on the "operator" field.
+func OperatorNotIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldOperator, vs...))
+}
+
+// OperatorGT applies the GT predicate on the "operator" field.
+func OperatorGT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldOperator, v))
+}
+
+// OperatorGTE applies the GTE predicate on the "operator" field.
+func OperatorGTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldOperator, v))
+}
+
+// OperatorLT applies the LT predicate on the "operator" field.
+func OperatorLT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldOperator, v))
+}
+
+// OperatorLTE applies the LTE predicate on the "operator" field.
+func OperatorLTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldOperator, v))
+}
+
+// OperatorContains applies the Contains predicate on the "operator" field.
+func OperatorContains(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContains(FieldOperator, v))
+}
+
+// OperatorHasPrefix applies the HasPrefix predicate on the "operator" field.
+func OperatorHasPrefix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasPrefix(FieldOperator, v))
+}
+
+// OperatorHasSuffix applies the HasSuffix predicate on the "operator" field.
+func OperatorHasSuffix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasSuffix(FieldOperator, v))
+}
+
+// OperatorIsNil applies the IsNil predicate on the "operator" field.
+func OperatorIsNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIsNull(FieldOperator))
+}
+
+// OperatorNotNil applies the NotNil predicate on the "operator" field.
+func OperatorNotNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotNull(FieldOperator))
+}
+
+// OperatorEqualFold applies the EqualFold predicate on the "operator" field.
+func OperatorEqualFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEqualFold(FieldOperator, v))
+}
+
+// OperatorContainsFold applies the ContainsFold predicate on the "operator" field.
+func OperatorContainsFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContainsFold(FieldOperator, v))
+}
+
+// TotalTargetsEQ applies the EQ predicate on the "total_targets" field.
+func TotalTargetsEQ(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldTotalTargets, v))
+}
+
+// TotalTargetsNEQ applies the NEQ predicate on the "total_targets" field.
+func TotalTargetsNEQ(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldTotalTargets, v))
+}
+
+// TotalTargetsIn applies the In predicate on the "total_targets" field.
+func TotalTargetsIn(vs ...int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldTotalTargets, vs...))
+}
+
+// TotalTargetsNotIn applies the NotIn predicate on the "total_targets" field.
+func TotalTargetsNotIn(vs ...int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldTotalTargets, vs...))
+}
+
+// TotalTargetsGT applies the GT predicate on the "total_targets" field.
+func TotalTargetsGT(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldTotalTargets, v))
+}
+
+// TotalTargetsGTE applies the GTE predicate on the "total_targets" field.
+func TotalTargetsGTE(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldTotalTargets, v))
+}
+
+// TotalTargetsLT applies the LT predicate on the "total_targets" field.
+func TotalTargetsLT(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldTotalTargets, v))
+}
+
+// TotalTargetsLTE applies the LTE predicate on the "total_targets" field.
+func TotalTargetsLTE(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldTotalTargets, v))
+}
+
+// DiffCountEQ applies the EQ predicate on the "diff_count" field.
+func DiffCountEQ(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldDiffCount, v))
+}
+
+// DiffCountNEQ applies the NEQ predicate on the "diff_count" field.
+func DiffCountNEQ(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldDiffCount, v))
+}
+
+// DiffCountIn applies the In predicate on the "diff_count" field.
+func DiffCountIn(vs ...int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldDiffCount, vs...))
+}
+
+// DiffCountNotIn applies the NotIn predicate on the "diff_count" field.
+func DiffCountNotIn(vs ...int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldDiffCount, vs...))
+}
+
+// DiffCountGT applies the GT predicate on the "diff_count" field.
+func DiffCountGT(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldDiffCount, v))
+}
+
+// DiffCountGTE applies the GTE predicate on the "diff_count" field.
+func DiffCountGTE(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldDiffCount, v))
+}
+
+// DiffCountLT applies the LT predicate on the "diff_count" field.
+func DiffCountLT(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldDiffCount, v))
+}
+
+// DiffCountLTE applies the LTE predicate on the "diff_count" field.
+func DiffCountLTE(v int) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldDiffCount, v))
+}
+
+// AdjustedEQ applies the EQ predicate on the "adjusted" field.
+func AdjustedEQ(v bool) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldAdjusted, v))
+}
+
+// AdjustedNEQ applies the NEQ predicate on the "adjusted" field.
+func AdjustedNEQ(v bool) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldAdjusted, v))
+}
+
+// AdjustNoEQ applies the EQ predicate on the "adjust_no" field.
+func AdjustNoEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldAdjustNo, v))
+}
+
+// AdjustNoNEQ applies the NEQ predicate on the "adjust_no" field.
+func AdjustNoNEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldAdjustNo, v))
+}
+
+// AdjustNoIn applies the In predicate on the "adjust_no" field.
+func AdjustNoIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldAdjustNo, vs...))
+}
+
+// AdjustNoNotIn applies the NotIn predicate on the "adjust_no" field.
+func AdjustNoNotIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldAdjustNo, vs...))
+}
+
+// AdjustNoGT applies the GT predicate on the "adjust_no" field.
+func AdjustNoGT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldAdjustNo, v))
+}
+
+// AdjustNoGTE applies the GTE predicate on the "adjust_no" field.
+func AdjustNoGTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldAdjustNo, v))
+}
+
+// AdjustNoLT applies the LT predicate on the "adjust_no" field.
+func AdjustNoLT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldAdjustNo, v))
+}
+
+// AdjustNoLTE applies the LTE predicate on the "adjust_no" field.
+func AdjustNoLTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldAdjustNo, v))
+}
+
+// AdjustNoContains applies the Contains predicate on the "adjust_no" field.
+func AdjustNoContains(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContains(FieldAdjustNo, v))
+}
+
+// AdjustNoHasPrefix applies the HasPrefix predicate on the "adjust_no" field.
+func AdjustNoHasPrefix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasPrefix(FieldAdjustNo, v))
+}
+
+// AdjustNoHasSuffix applies the HasSuffix predicate on the "adjust_no" field.
+func AdjustNoHasSuffix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasSuffix(FieldAdjustNo, v))
+}
+
+// AdjustNoIsNil applies the IsNil predicate on the "adjust_no" field.
+func AdjustNoIsNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIsNull(FieldAdjustNo))
+}
+
+// AdjustNoNotNil applies the NotNil predicate on the "adjust_no" field.
+func AdjustNoNotNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotNull(FieldAdjustNo))
+}
+
+// AdjustNoEqualFold applies the EqualFold predicate on the "adjust_no" field.
+func AdjustNoEqualFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEqualFold(FieldAdjustNo, v))
+}
+
+// AdjustNoContainsFold applies the ContainsFold predicate on the "adjust_no" field.
+func AdjustNoContainsFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContainsFold(FieldAdjustNo, v))
+}
+
+// WrittenAtEQ applies the EQ predicate on the "written_at" field.
+func WrittenAtEQ(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldWrittenAt, v))
+}
+
+// WrittenAtNEQ applies the NEQ predicate on the "written_at" field.
+func WrittenAtNEQ(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldWrittenAt, v))
+}
+
+// WrittenAtIn applies the In predicate on the "written_at" field.
+func WrittenAtIn(vs ...int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldWrittenAt, vs...))
+}
+
+// WrittenAtNotIn applies the NotIn predicate on the "written_at" field.
+func WrittenAtNotIn(vs ...int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldWrittenAt, vs...))
+}
+
+// WrittenAtGT applies the GT predicate on the "written_at" field.
+func WrittenAtGT(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldWrittenAt, v))
+}
+
+// WrittenAtGTE applies the GTE predicate on the "written_at" field.
+func WrittenAtGTE(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldWrittenAt, v))
+}
+
+// WrittenAtLT applies the LT predicate on the "written_at" field.
+func WrittenAtLT(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldWrittenAt, v))
+}
+
+// WrittenAtLTE applies the LTE predicate on the "written_at" field.
+func WrittenAtLTE(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldWrittenAt, v))
+}
+
+// WrittenAtIsNil applies the IsNil predicate on the "written_at" field.
+func WrittenAtIsNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIsNull(FieldWrittenAt))
+}
+
+// WrittenAtNotNil applies the NotNil predicate on the "written_at" field.
+func WrittenAtNotNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotNull(FieldWrittenAt))
+}
+
+// WrittenByEQ applies the EQ predicate on the "written_by" field.
+func WrittenByEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldWrittenBy, v))
+}
+
+// WrittenByNEQ applies the NEQ predicate on the "written_by" field.
+func WrittenByNEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldWrittenBy, v))
+}
+
+// WrittenByIn applies the In predicate on the "written_by" field.
+func WrittenByIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldWrittenBy, vs...))
+}
+
+// WrittenByNotIn applies the NotIn predicate on the "written_by" field.
+func WrittenByNotIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldWrittenBy, vs...))
+}
+
+// WrittenByGT applies the GT predicate on the "written_by" field.
+func WrittenByGT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldWrittenBy, v))
+}
+
+// WrittenByGTE applies the GTE predicate on the "written_by" field.
+func WrittenByGTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldWrittenBy, v))
+}
+
+// WrittenByLT applies the LT predicate on the "written_by" field.
+func WrittenByLT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldWrittenBy, v))
+}
+
+// WrittenByLTE applies the LTE predicate on the "written_by" field.
+func WrittenByLTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldWrittenBy, v))
+}
+
+// WrittenByContains applies the Contains predicate on the "written_by" field.
+func WrittenByContains(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContains(FieldWrittenBy, v))
+}
+
+// WrittenByHasPrefix applies the HasPrefix predicate on the "written_by" field.
+func WrittenByHasPrefix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasPrefix(FieldWrittenBy, v))
+}
+
+// WrittenByHasSuffix applies the HasSuffix predicate on the "written_by" field.
+func WrittenByHasSuffix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasSuffix(FieldWrittenBy, v))
+}
+
+// WrittenByIsNil applies the IsNil predicate on the "written_by" field.
+func WrittenByIsNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIsNull(FieldWrittenBy))
+}
+
+// WrittenByNotNil applies the NotNil predicate on the "written_by" field.
+func WrittenByNotNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotNull(FieldWrittenBy))
+}
+
+// WrittenByEqualFold applies the EqualFold predicate on the "written_by" field.
+func WrittenByEqualFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEqualFold(FieldWrittenBy, v))
+}
+
+// WrittenByContainsFold applies the ContainsFold predicate on the "written_by" field.
+func WrittenByContainsFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContainsFold(FieldWrittenBy, v))
+}
+
+// UncountedModeEQ applies the EQ predicate on the "uncounted_mode" field.
+func UncountedModeEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldUncountedMode, v))
+}
+
+// UncountedModeNEQ applies the NEQ predicate on the "uncounted_mode" field.
+func UncountedModeNEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldUncountedMode, v))
+}
+
+// UncountedModeIn applies the In predicate on the "uncounted_mode" field.
+func UncountedModeIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldUncountedMode, vs...))
+}
+
+// UncountedModeNotIn applies the NotIn predicate on the "uncounted_mode" field.
+func UncountedModeNotIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldUncountedMode, vs...))
+}
+
+// UncountedModeGT applies the GT predicate on the "uncounted_mode" field.
+func UncountedModeGT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldUncountedMode, v))
+}
+
+// UncountedModeGTE applies the GTE predicate on the "uncounted_mode" field.
+func UncountedModeGTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldUncountedMode, v))
+}
+
+// UncountedModeLT applies the LT predicate on the "uncounted_mode" field.
+func UncountedModeLT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldUncountedMode, v))
+}
+
+// UncountedModeLTE applies the LTE predicate on the "uncounted_mode" field.
+func UncountedModeLTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldUncountedMode, v))
+}
+
+// UncountedModeContains applies the Contains predicate on the "uncounted_mode" field.
+func UncountedModeContains(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContains(FieldUncountedMode, v))
+}
+
+// UncountedModeHasPrefix applies the HasPrefix predicate on the "uncounted_mode" field.
+func UncountedModeHasPrefix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasPrefix(FieldUncountedMode, v))
+}
+
+// UncountedModeHasSuffix applies the HasSuffix predicate on the "uncounted_mode" field.
+func UncountedModeHasSuffix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasSuffix(FieldUncountedMode, v))
+}
+
+// UncountedModeIsNil applies the IsNil predicate on the "uncounted_mode" field.
+func UncountedModeIsNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIsNull(FieldUncountedMode))
+}
+
+// UncountedModeNotNil applies the NotNil predicate on the "uncounted_mode" field.
+func UncountedModeNotNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotNull(FieldUncountedMode))
+}
+
+// UncountedModeEqualFold applies the EqualFold predicate on the "uncounted_mode" field.
+func UncountedModeEqualFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEqualFold(FieldUncountedMode, v))
+}
+
+// UncountedModeContainsFold applies the ContainsFold predicate on the "uncounted_mode" field.
+func UncountedModeContainsFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContainsFold(FieldUncountedMode, v))
+}
+
+// CancelReasonEQ applies the EQ predicate on the "cancel_reason" field.
+func CancelReasonEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldCancelReason, v))
+}
+
+// CancelReasonNEQ applies the NEQ predicate on the "cancel_reason" field.
+func CancelReasonNEQ(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldCancelReason, v))
+}
+
+// CancelReasonIn applies the In predicate on the "cancel_reason" field.
+func CancelReasonIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldCancelReason, vs...))
+}
+
+// CancelReasonNotIn applies the NotIn predicate on the "cancel_reason" field.
+func CancelReasonNotIn(vs ...string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldCancelReason, vs...))
+}
+
+// CancelReasonGT applies the GT predicate on the "cancel_reason" field.
+func CancelReasonGT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldCancelReason, v))
+}
+
+// CancelReasonGTE applies the GTE predicate on the "cancel_reason" field.
+func CancelReasonGTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldCancelReason, v))
+}
+
+// CancelReasonLT applies the LT predicate on the "cancel_reason" field.
+func CancelReasonLT(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldCancelReason, v))
+}
+
+// CancelReasonLTE applies the LTE predicate on the "cancel_reason" field.
+func CancelReasonLTE(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldCancelReason, v))
+}
+
+// CancelReasonContains applies the Contains predicate on the "cancel_reason" field.
+func CancelReasonContains(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContains(FieldCancelReason, v))
+}
+
+// CancelReasonHasPrefix applies the HasPrefix predicate on the "cancel_reason" field.
+func CancelReasonHasPrefix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasPrefix(FieldCancelReason, v))
+}
+
+// CancelReasonHasSuffix applies the HasSuffix predicate on the "cancel_reason" field.
+func CancelReasonHasSuffix(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldHasSuffix(FieldCancelReason, v))
+}
+
+// CancelReasonIsNil applies the IsNil predicate on the "cancel_reason" field.
+func CancelReasonIsNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIsNull(FieldCancelReason))
+}
+
+// CancelReasonNotNil applies the NotNil predicate on the "cancel_reason" field.
+func CancelReasonNotNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotNull(FieldCancelReason))
+}
+
+// CancelReasonEqualFold applies the EqualFold predicate on the "cancel_reason" field.
+func CancelReasonEqualFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEqualFold(FieldCancelReason, v))
+}
+
+// CancelReasonContainsFold applies the ContainsFold predicate on the "cancel_reason" field.
+func CancelReasonContainsFold(v string) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldContainsFold(FieldCancelReason, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// FinishedAtEQ applies the EQ predicate on the "finished_at" field.
+func FinishedAtEQ(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldEQ(FieldFinishedAt, v))
+}
+
+// FinishedAtNEQ applies the NEQ predicate on the "finished_at" field.
+func FinishedAtNEQ(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNEQ(FieldFinishedAt, v))
+}
+
+// FinishedAtIn applies the In predicate on the "finished_at" field.
+func FinishedAtIn(vs ...int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIn(FieldFinishedAt, vs...))
+}
+
+// FinishedAtNotIn applies the NotIn predicate on the "finished_at" field.
+func FinishedAtNotIn(vs ...int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotIn(FieldFinishedAt, vs...))
+}
+
+// FinishedAtGT applies the GT predicate on the "finished_at" field.
+func FinishedAtGT(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGT(FieldFinishedAt, v))
+}
+
+// FinishedAtGTE applies the GTE predicate on the "finished_at" field.
+func FinishedAtGTE(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldGTE(FieldFinishedAt, v))
+}
+
+// FinishedAtLT applies the LT predicate on the "finished_at" field.
+func FinishedAtLT(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLT(FieldFinishedAt, v))
+}
+
+// FinishedAtLTE applies the LTE predicate on the "finished_at" field.
+func FinishedAtLTE(v int64) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldLTE(FieldFinishedAt, v))
+}
+
+// FinishedAtIsNil applies the IsNil predicate on the "finished_at" field.
+func FinishedAtIsNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldIsNull(FieldFinishedAt))
+}
+
+// FinishedAtNotNil applies the NotNil predicate on the "finished_at" field.
+func FinishedAtNotNil() predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.FieldNotNull(FieldFinishedAt))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.StocktakeOrder) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.StocktakeOrder) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.StocktakeOrder) predicate.StocktakeOrder {
+	return predicate.StocktakeOrder(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/user/user.go b/bj_power_wms/user/user.go
new file mode 100644
index 0000000..fc1ed7e
--- /dev/null
+++ b/bj_power_wms/user/user.go
@@ -0,0 +1,138 @@
+// Code generated by ent, DO NOT EDIT.
+
+package user
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the user type in the database.
+	Label = "user"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldUsername holds the string denoting the username field in the database.
+	FieldUsername = "username"
+	// FieldPassword holds the string denoting the password field in the database.
+	FieldPassword = "password"
+	// FieldRealName holds the string denoting the real_name field in the database.
+	FieldRealName = "real_name"
+	// FieldRole holds the string denoting the role field in the database.
+	FieldRole = "role"
+	// FieldRoleID holds the string denoting the role_id field in the database.
+	FieldRoleID = "role_id"
+	// FieldDept holds the string denoting the dept field in the database.
+	FieldDept = "dept"
+	// FieldPhone holds the string denoting the phone field in the database.
+	FieldPhone = "phone"
+	// FieldIsActive holds the string denoting the is_active field in the database.
+	FieldIsActive = "is_active"
+	// FieldLastLoginAt holds the string denoting the last_login_at field in the database.
+	FieldLastLoginAt = "last_login_at"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the user in the database.
+	Table = "users"
+)
+
+// Columns holds all SQL columns for user fields.
+var Columns = []string{
+	FieldID,
+	FieldUsername,
+	FieldPassword,
+	FieldRealName,
+	FieldRole,
+	FieldRoleID,
+	FieldDept,
+	FieldPhone,
+	FieldIsActive,
+	FieldLastLoginAt,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultRole holds the default value on creation for the "role" field.
+	DefaultRole string
+	// DefaultIsActive holds the default value on creation for the "is_active" field.
+	DefaultIsActive bool
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the User queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByUsername orders the results by the username field.
+func ByUsername(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUsername, opts...).ToFunc()
+}
+
+// ByPassword orders the results by the password field.
+func ByPassword(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPassword, opts...).ToFunc()
+}
+
+// ByRealName orders the results by the real_name field.
+func ByRealName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRealName, opts...).ToFunc()
+}
+
+// ByRole orders the results by the role field.
+func ByRole(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRole, opts...).ToFunc()
+}
+
+// ByRoleID orders the results by the role_id field.
+func ByRoleID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldRoleID, opts...).ToFunc()
+}
+
+// ByDept orders the results by the dept field.
+func ByDept(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDept, opts...).ToFunc()
+}
+
+// ByPhone orders the results by the phone field.
+func ByPhone(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPhone, opts...).ToFunc()
+}
+
+// ByIsActive orders the results by the is_active field.
+func ByIsActive(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldIsActive, opts...).ToFunc()
+}
+
+// ByLastLoginAt orders the results by the last_login_at field.
+func ByLastLoginAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLastLoginAt, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
diff --git a/bj_power_wms/user/where.go b/bj_power_wms/user/where.go
new file mode 100644
index 0000000..c2bd118
--- /dev/null
+++ b/bj_power_wms/user/where.go
@@ -0,0 +1,734 @@
+// Code generated by ent, DO NOT EDIT.
+
+package user
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.User {
+	return predicate.User(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.User {
+	return predicate.User(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.User {
+	return predicate.User(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldID, id))
+}
+
+// Username applies equality check predicate on the "username" field. It's identical to UsernameEQ.
+func Username(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldUsername, v))
+}
+
+// Password applies equality check predicate on the "password" field. It's identical to PasswordEQ.
+func Password(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldPassword, v))
+}
+
+// RealName applies equality check predicate on the "real_name" field. It's identical to RealNameEQ.
+func RealName(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldRealName, v))
+}
+
+// Role applies equality check predicate on the "role" field. It's identical to RoleEQ.
+func Role(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldRole, v))
+}
+
+// RoleID applies equality check predicate on the "role_id" field. It's identical to RoleIDEQ.
+func RoleID(v int) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldRoleID, v))
+}
+
+// Dept applies equality check predicate on the "dept" field. It's identical to DeptEQ.
+func Dept(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldDept, v))
+}
+
+// Phone applies equality check predicate on the "phone" field. It's identical to PhoneEQ.
+func Phone(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldPhone, v))
+}
+
+// IsActive applies equality check predicate on the "is_active" field. It's identical to IsActiveEQ.
+func IsActive(v bool) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldIsActive, v))
+}
+
+// LastLoginAt applies equality check predicate on the "last_login_at" field. It's identical to LastLoginAtEQ.
+func LastLoginAt(v int64) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldLastLoginAt, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UsernameEQ applies the EQ predicate on the "username" field.
+func UsernameEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldUsername, v))
+}
+
+// UsernameNEQ applies the NEQ predicate on the "username" field.
+func UsernameNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldUsername, v))
+}
+
+// UsernameIn applies the In predicate on the "username" field.
+func UsernameIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldUsername, vs...))
+}
+
+// UsernameNotIn applies the NotIn predicate on the "username" field.
+func UsernameNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldUsername, vs...))
+}
+
+// UsernameGT applies the GT predicate on the "username" field.
+func UsernameGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldUsername, v))
+}
+
+// UsernameGTE applies the GTE predicate on the "username" field.
+func UsernameGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldUsername, v))
+}
+
+// UsernameLT applies the LT predicate on the "username" field.
+func UsernameLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldUsername, v))
+}
+
+// UsernameLTE applies the LTE predicate on the "username" field.
+func UsernameLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldUsername, v))
+}
+
+// UsernameContains applies the Contains predicate on the "username" field.
+func UsernameContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldUsername, v))
+}
+
+// UsernameHasPrefix applies the HasPrefix predicate on the "username" field.
+func UsernameHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldUsername, v))
+}
+
+// UsernameHasSuffix applies the HasSuffix predicate on the "username" field.
+func UsernameHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldUsername, v))
+}
+
+// UsernameEqualFold applies the EqualFold predicate on the "username" field.
+func UsernameEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldUsername, v))
+}
+
+// UsernameContainsFold applies the ContainsFold predicate on the "username" field.
+func UsernameContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldUsername, v))
+}
+
+// PasswordEQ applies the EQ predicate on the "password" field.
+func PasswordEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldPassword, v))
+}
+
+// PasswordNEQ applies the NEQ predicate on the "password" field.
+func PasswordNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldPassword, v))
+}
+
+// PasswordIn applies the In predicate on the "password" field.
+func PasswordIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldPassword, vs...))
+}
+
+// PasswordNotIn applies the NotIn predicate on the "password" field.
+func PasswordNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldPassword, vs...))
+}
+
+// PasswordGT applies the GT predicate on the "password" field.
+func PasswordGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldPassword, v))
+}
+
+// PasswordGTE applies the GTE predicate on the "password" field.
+func PasswordGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldPassword, v))
+}
+
+// PasswordLT applies the LT predicate on the "password" field.
+func PasswordLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldPassword, v))
+}
+
+// PasswordLTE applies the LTE predicate on the "password" field.
+func PasswordLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldPassword, v))
+}
+
+// PasswordContains applies the Contains predicate on the "password" field.
+func PasswordContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldPassword, v))
+}
+
+// PasswordHasPrefix applies the HasPrefix predicate on the "password" field.
+func PasswordHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldPassword, v))
+}
+
+// PasswordHasSuffix applies the HasSuffix predicate on the "password" field.
+func PasswordHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldPassword, v))
+}
+
+// PasswordEqualFold applies the EqualFold predicate on the "password" field.
+func PasswordEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldPassword, v))
+}
+
+// PasswordContainsFold applies the ContainsFold predicate on the "password" field.
+func PasswordContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldPassword, v))
+}
+
+// RealNameEQ applies the EQ predicate on the "real_name" field.
+func RealNameEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldRealName, v))
+}
+
+// RealNameNEQ applies the NEQ predicate on the "real_name" field.
+func RealNameNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldRealName, v))
+}
+
+// RealNameIn applies the In predicate on the "real_name" field.
+func RealNameIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldRealName, vs...))
+}
+
+// RealNameNotIn applies the NotIn predicate on the "real_name" field.
+func RealNameNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldRealName, vs...))
+}
+
+// RealNameGT applies the GT predicate on the "real_name" field.
+func RealNameGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldRealName, v))
+}
+
+// RealNameGTE applies the GTE predicate on the "real_name" field.
+func RealNameGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldRealName, v))
+}
+
+// RealNameLT applies the LT predicate on the "real_name" field.
+func RealNameLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldRealName, v))
+}
+
+// RealNameLTE applies the LTE predicate on the "real_name" field.
+func RealNameLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldRealName, v))
+}
+
+// RealNameContains applies the Contains predicate on the "real_name" field.
+func RealNameContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldRealName, v))
+}
+
+// RealNameHasPrefix applies the HasPrefix predicate on the "real_name" field.
+func RealNameHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldRealName, v))
+}
+
+// RealNameHasSuffix applies the HasSuffix predicate on the "real_name" field.
+func RealNameHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldRealName, v))
+}
+
+// RealNameIsNil applies the IsNil predicate on the "real_name" field.
+func RealNameIsNil() predicate.User {
+	return predicate.User(sql.FieldIsNull(FieldRealName))
+}
+
+// RealNameNotNil applies the NotNil predicate on the "real_name" field.
+func RealNameNotNil() predicate.User {
+	return predicate.User(sql.FieldNotNull(FieldRealName))
+}
+
+// RealNameEqualFold applies the EqualFold predicate on the "real_name" field.
+func RealNameEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldRealName, v))
+}
+
+// RealNameContainsFold applies the ContainsFold predicate on the "real_name" field.
+func RealNameContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldRealName, v))
+}
+
+// RoleEQ applies the EQ predicate on the "role" field.
+func RoleEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldRole, v))
+}
+
+// RoleNEQ applies the NEQ predicate on the "role" field.
+func RoleNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldRole, v))
+}
+
+// RoleIn applies the In predicate on the "role" field.
+func RoleIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldRole, vs...))
+}
+
+// RoleNotIn applies the NotIn predicate on the "role" field.
+func RoleNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldRole, vs...))
+}
+
+// RoleGT applies the GT predicate on the "role" field.
+func RoleGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldRole, v))
+}
+
+// RoleGTE applies the GTE predicate on the "role" field.
+func RoleGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldRole, v))
+}
+
+// RoleLT applies the LT predicate on the "role" field.
+func RoleLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldRole, v))
+}
+
+// RoleLTE applies the LTE predicate on the "role" field.
+func RoleLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldRole, v))
+}
+
+// RoleContains applies the Contains predicate on the "role" field.
+func RoleContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldRole, v))
+}
+
+// RoleHasPrefix applies the HasPrefix predicate on the "role" field.
+func RoleHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldRole, v))
+}
+
+// RoleHasSuffix applies the HasSuffix predicate on the "role" field.
+func RoleHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldRole, v))
+}
+
+// RoleEqualFold applies the EqualFold predicate on the "role" field.
+func RoleEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldRole, v))
+}
+
+// RoleContainsFold applies the ContainsFold predicate on the "role" field.
+func RoleContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldRole, v))
+}
+
+// RoleIDEQ applies the EQ predicate on the "role_id" field.
+func RoleIDEQ(v int) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldRoleID, v))
+}
+
+// RoleIDNEQ applies the NEQ predicate on the "role_id" field.
+func RoleIDNEQ(v int) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldRoleID, v))
+}
+
+// RoleIDIn applies the In predicate on the "role_id" field.
+func RoleIDIn(vs ...int) predicate.User {
+	return predicate.User(sql.FieldIn(FieldRoleID, vs...))
+}
+
+// RoleIDNotIn applies the NotIn predicate on the "role_id" field.
+func RoleIDNotIn(vs ...int) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldRoleID, vs...))
+}
+
+// RoleIDGT applies the GT predicate on the "role_id" field.
+func RoleIDGT(v int) predicate.User {
+	return predicate.User(sql.FieldGT(FieldRoleID, v))
+}
+
+// RoleIDGTE applies the GTE predicate on the "role_id" field.
+func RoleIDGTE(v int) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldRoleID, v))
+}
+
+// RoleIDLT applies the LT predicate on the "role_id" field.
+func RoleIDLT(v int) predicate.User {
+	return predicate.User(sql.FieldLT(FieldRoleID, v))
+}
+
+// RoleIDLTE applies the LTE predicate on the "role_id" field.
+func RoleIDLTE(v int) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldRoleID, v))
+}
+
+// RoleIDIsNil applies the IsNil predicate on the "role_id" field.
+func RoleIDIsNil() predicate.User {
+	return predicate.User(sql.FieldIsNull(FieldRoleID))
+}
+
+// RoleIDNotNil applies the NotNil predicate on the "role_id" field.
+func RoleIDNotNil() predicate.User {
+	return predicate.User(sql.FieldNotNull(FieldRoleID))
+}
+
+// DeptEQ applies the EQ predicate on the "dept" field.
+func DeptEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldDept, v))
+}
+
+// DeptNEQ applies the NEQ predicate on the "dept" field.
+func DeptNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldDept, v))
+}
+
+// DeptIn applies the In predicate on the "dept" field.
+func DeptIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldDept, vs...))
+}
+
+// DeptNotIn applies the NotIn predicate on the "dept" field.
+func DeptNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldDept, vs...))
+}
+
+// DeptGT applies the GT predicate on the "dept" field.
+func DeptGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldDept, v))
+}
+
+// DeptGTE applies the GTE predicate on the "dept" field.
+func DeptGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldDept, v))
+}
+
+// DeptLT applies the LT predicate on the "dept" field.
+func DeptLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldDept, v))
+}
+
+// DeptLTE applies the LTE predicate on the "dept" field.
+func DeptLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldDept, v))
+}
+
+// DeptContains applies the Contains predicate on the "dept" field.
+func DeptContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldDept, v))
+}
+
+// DeptHasPrefix applies the HasPrefix predicate on the "dept" field.
+func DeptHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldDept, v))
+}
+
+// DeptHasSuffix applies the HasSuffix predicate on the "dept" field.
+func DeptHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldDept, v))
+}
+
+// DeptIsNil applies the IsNil predicate on the "dept" field.
+func DeptIsNil() predicate.User {
+	return predicate.User(sql.FieldIsNull(FieldDept))
+}
+
+// DeptNotNil applies the NotNil predicate on the "dept" field.
+func DeptNotNil() predicate.User {
+	return predicate.User(sql.FieldNotNull(FieldDept))
+}
+
+// DeptEqualFold applies the EqualFold predicate on the "dept" field.
+func DeptEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldDept, v))
+}
+
+// DeptContainsFold applies the ContainsFold predicate on the "dept" field.
+func DeptContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldDept, v))
+}
+
+// PhoneEQ applies the EQ predicate on the "phone" field.
+func PhoneEQ(v string) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldPhone, v))
+}
+
+// PhoneNEQ applies the NEQ predicate on the "phone" field.
+func PhoneNEQ(v string) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldPhone, v))
+}
+
+// PhoneIn applies the In predicate on the "phone" field.
+func PhoneIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldIn(FieldPhone, vs...))
+}
+
+// PhoneNotIn applies the NotIn predicate on the "phone" field.
+func PhoneNotIn(vs ...string) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldPhone, vs...))
+}
+
+// PhoneGT applies the GT predicate on the "phone" field.
+func PhoneGT(v string) predicate.User {
+	return predicate.User(sql.FieldGT(FieldPhone, v))
+}
+
+// PhoneGTE applies the GTE predicate on the "phone" field.
+func PhoneGTE(v string) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldPhone, v))
+}
+
+// PhoneLT applies the LT predicate on the "phone" field.
+func PhoneLT(v string) predicate.User {
+	return predicate.User(sql.FieldLT(FieldPhone, v))
+}
+
+// PhoneLTE applies the LTE predicate on the "phone" field.
+func PhoneLTE(v string) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldPhone, v))
+}
+
+// PhoneContains applies the Contains predicate on the "phone" field.
+func PhoneContains(v string) predicate.User {
+	return predicate.User(sql.FieldContains(FieldPhone, v))
+}
+
+// PhoneHasPrefix applies the HasPrefix predicate on the "phone" field.
+func PhoneHasPrefix(v string) predicate.User {
+	return predicate.User(sql.FieldHasPrefix(FieldPhone, v))
+}
+
+// PhoneHasSuffix applies the HasSuffix predicate on the "phone" field.
+func PhoneHasSuffix(v string) predicate.User {
+	return predicate.User(sql.FieldHasSuffix(FieldPhone, v))
+}
+
+// PhoneIsNil applies the IsNil predicate on the "phone" field.
+func PhoneIsNil() predicate.User {
+	return predicate.User(sql.FieldIsNull(FieldPhone))
+}
+
+// PhoneNotNil applies the NotNil predicate on the "phone" field.
+func PhoneNotNil() predicate.User {
+	return predicate.User(sql.FieldNotNull(FieldPhone))
+}
+
+// PhoneEqualFold applies the EqualFold predicate on the "phone" field.
+func PhoneEqualFold(v string) predicate.User {
+	return predicate.User(sql.FieldEqualFold(FieldPhone, v))
+}
+
+// PhoneContainsFold applies the ContainsFold predicate on the "phone" field.
+func PhoneContainsFold(v string) predicate.User {
+	return predicate.User(sql.FieldContainsFold(FieldPhone, v))
+}
+
+// IsActiveEQ applies the EQ predicate on the "is_active" field.
+func IsActiveEQ(v bool) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldIsActive, v))
+}
+
+// IsActiveNEQ applies the NEQ predicate on the "is_active" field.
+func IsActiveNEQ(v bool) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldIsActive, v))
+}
+
+// LastLoginAtEQ applies the EQ predicate on the "last_login_at" field.
+func LastLoginAtEQ(v int64) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldLastLoginAt, v))
+}
+
+// LastLoginAtNEQ applies the NEQ predicate on the "last_login_at" field.
+func LastLoginAtNEQ(v int64) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldLastLoginAt, v))
+}
+
+// LastLoginAtIn applies the In predicate on the "last_login_at" field.
+func LastLoginAtIn(vs ...int64) predicate.User {
+	return predicate.User(sql.FieldIn(FieldLastLoginAt, vs...))
+}
+
+// LastLoginAtNotIn applies the NotIn predicate on the "last_login_at" field.
+func LastLoginAtNotIn(vs ...int64) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldLastLoginAt, vs...))
+}
+
+// LastLoginAtGT applies the GT predicate on the "last_login_at" field.
+func LastLoginAtGT(v int64) predicate.User {
+	return predicate.User(sql.FieldGT(FieldLastLoginAt, v))
+}
+
+// LastLoginAtGTE applies the GTE predicate on the "last_login_at" field.
+func LastLoginAtGTE(v int64) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldLastLoginAt, v))
+}
+
+// LastLoginAtLT applies the LT predicate on the "last_login_at" field.
+func LastLoginAtLT(v int64) predicate.User {
+	return predicate.User(sql.FieldLT(FieldLastLoginAt, v))
+}
+
+// LastLoginAtLTE applies the LTE predicate on the "last_login_at" field.
+func LastLoginAtLTE(v int64) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldLastLoginAt, v))
+}
+
+// LastLoginAtIsNil applies the IsNil predicate on the "last_login_at" field.
+func LastLoginAtIsNil() predicate.User {
+	return predicate.User(sql.FieldIsNull(FieldLastLoginAt))
+}
+
+// LastLoginAtNotNil applies the NotNil predicate on the "last_login_at" field.
+func LastLoginAtNotNil() predicate.User {
+	return predicate.User(sql.FieldNotNull(FieldLastLoginAt))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.User {
+	return predicate.User(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.User {
+	return predicate.User(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.User {
+	return predicate.User(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.User {
+	return predicate.User(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.User {
+	return predicate.User(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.User {
+	return predicate.User(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.User {
+	return predicate.User(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.User {
+	return predicate.User(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.User {
+	return predicate.User(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.User {
+	return predicate.User(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.User {
+	return predicate.User(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.User) predicate.User {
+	return predicate.User(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.User) predicate.User {
+	return predicate.User(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.User) predicate.User {
+	return predicate.User(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/web/static/index.html b/bj_power_wms/web/static/index.html
index f0af58a..c00bce3 100644
--- a/bj_power_wms/web/static/index.html
+++ b/bj_power_wms/web/static/index.html
@@ -6,7 +6,7 @@
   <title>WMS库房管理</title>
   <!-- 系统图标：库房箱体（内联 SVG，避免依赖外部文件） -->
   <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'><rect width='32' height='32' rx='6' fill='%231668dc'/><path d='M16 7l9 4.5v9L16 25l-9-4.5v-9L16 7z' fill='none' stroke='%23fff' stroke-width='2' stroke-linejoin='round'/><path d='M7 11.5L16 16l9-4.5M16 16v9' fill='none' stroke='%23fff' stroke-width='2' stroke-linejoin='round'/></svg>">
-  <script type="module" crossorigin src="/assets/index-De2OnHlD.js"></script>
+  <script type="module" crossorigin src="/assets/index-DHfOD6bV.js"></script>
   <link rel="stylesheet" crossorigin href="/assets/index-hzpIaM_X.css">
 </head>
 <body>
diff --git a/bj_power_wms/zone/where.go b/bj_power_wms/zone/where.go
new file mode 100644
index 0000000..fe29b53
--- /dev/null
+++ b/bj_power_wms/zone/where.go
@@ -0,0 +1,984 @@
+// Code generated by ent, DO NOT EDIT.
+
+package zone
+
+import (
+	"bj_power_wms/predicate"
+
+	"entgo.io/ent/dialect/sql"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldID, id))
+}
+
+// Level applies equality check predicate on the "level" field. It's identical to LevelEQ.
+func Level(v int) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldLevel, v))
+}
+
+// Code applies equality check predicate on the "code" field. It's identical to CodeEQ.
+func Code(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldCode, v))
+}
+
+// Name applies equality check predicate on the "name" field. It's identical to NameEQ.
+func Name(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldName, v))
+}
+
+// ParentCode applies equality check predicate on the "parent_code" field. It's identical to ParentCodeEQ.
+func ParentCode(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldParentCode, v))
+}
+
+// ZoneCode applies equality check predicate on the "zone_code" field. It's identical to ZoneCodeEQ.
+func ZoneCode(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ZoneName applies equality check predicate on the "zone_name" field. It's identical to ZoneNameEQ.
+func ZoneName(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldZoneName, v))
+}
+
+// Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ.
+func Description(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldDescription, v))
+}
+
+// ShelfNo applies equality check predicate on the "shelf_no" field. It's identical to ShelfNoEQ.
+func ShelfNo(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// LayerNo applies equality check predicate on the "layer_no" field. It's identical to LayerNoEQ.
+func LayerNo(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// PositionNo applies equality check predicate on the "position_no" field. It's identical to PositionNoEQ.
+func PositionNo(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// Status applies equality check predicate on the "status" field. It's identical to StatusEQ.
+func Status(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldStatus, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// LevelEQ applies the EQ predicate on the "level" field.
+func LevelEQ(v int) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldLevel, v))
+}
+
+// LevelNEQ applies the NEQ predicate on the "level" field.
+func LevelNEQ(v int) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldLevel, v))
+}
+
+// LevelIn applies the In predicate on the "level" field.
+func LevelIn(vs ...int) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldLevel, vs...))
+}
+
+// LevelNotIn applies the NotIn predicate on the "level" field.
+func LevelNotIn(vs ...int) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldLevel, vs...))
+}
+
+// LevelGT applies the GT predicate on the "level" field.
+func LevelGT(v int) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldLevel, v))
+}
+
+// LevelGTE applies the GTE predicate on the "level" field.
+func LevelGTE(v int) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldLevel, v))
+}
+
+// LevelLT applies the LT predicate on the "level" field.
+func LevelLT(v int) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldLevel, v))
+}
+
+// LevelLTE applies the LTE predicate on the "level" field.
+func LevelLTE(v int) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldLevel, v))
+}
+
+// CodeEQ applies the EQ predicate on the "code" field.
+func CodeEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldCode, v))
+}
+
+// CodeNEQ applies the NEQ predicate on the "code" field.
+func CodeNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldCode, v))
+}
+
+// CodeIn applies the In predicate on the "code" field.
+func CodeIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldCode, vs...))
+}
+
+// CodeNotIn applies the NotIn predicate on the "code" field.
+func CodeNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldCode, vs...))
+}
+
+// CodeGT applies the GT predicate on the "code" field.
+func CodeGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldCode, v))
+}
+
+// CodeGTE applies the GTE predicate on the "code" field.
+func CodeGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldCode, v))
+}
+
+// CodeLT applies the LT predicate on the "code" field.
+func CodeLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldCode, v))
+}
+
+// CodeLTE applies the LTE predicate on the "code" field.
+func CodeLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldCode, v))
+}
+
+// CodeContains applies the Contains predicate on the "code" field.
+func CodeContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldCode, v))
+}
+
+// CodeHasPrefix applies the HasPrefix predicate on the "code" field.
+func CodeHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldCode, v))
+}
+
+// CodeHasSuffix applies the HasSuffix predicate on the "code" field.
+func CodeHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldCode, v))
+}
+
+// CodeEqualFold applies the EqualFold predicate on the "code" field.
+func CodeEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldCode, v))
+}
+
+// CodeContainsFold applies the ContainsFold predicate on the "code" field.
+func CodeContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldCode, v))
+}
+
+// NameEQ applies the EQ predicate on the "name" field.
+func NameEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldName, v))
+}
+
+// NameNEQ applies the NEQ predicate on the "name" field.
+func NameNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldName, v))
+}
+
+// NameIn applies the In predicate on the "name" field.
+func NameIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldName, vs...))
+}
+
+// NameNotIn applies the NotIn predicate on the "name" field.
+func NameNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldName, vs...))
+}
+
+// NameGT applies the GT predicate on the "name" field.
+func NameGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldName, v))
+}
+
+// NameGTE applies the GTE predicate on the "name" field.
+func NameGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldName, v))
+}
+
+// NameLT applies the LT predicate on the "name" field.
+func NameLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldName, v))
+}
+
+// NameLTE applies the LTE predicate on the "name" field.
+func NameLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldName, v))
+}
+
+// NameContains applies the Contains predicate on the "name" field.
+func NameContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldName, v))
+}
+
+// NameHasPrefix applies the HasPrefix predicate on the "name" field.
+func NameHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldName, v))
+}
+
+// NameHasSuffix applies the HasSuffix predicate on the "name" field.
+func NameHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldName, v))
+}
+
+// NameIsNil applies the IsNil predicate on the "name" field.
+func NameIsNil() predicate.Zone {
+	return predicate.Zone(sql.FieldIsNull(FieldName))
+}
+
+// NameNotNil applies the NotNil predicate on the "name" field.
+func NameNotNil() predicate.Zone {
+	return predicate.Zone(sql.FieldNotNull(FieldName))
+}
+
+// NameEqualFold applies the EqualFold predicate on the "name" field.
+func NameEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldName, v))
+}
+
+// NameContainsFold applies the ContainsFold predicate on the "name" field.
+func NameContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldName, v))
+}
+
+// ParentCodeEQ applies the EQ predicate on the "parent_code" field.
+func ParentCodeEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldParentCode, v))
+}
+
+// ParentCodeNEQ applies the NEQ predicate on the "parent_code" field.
+func ParentCodeNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldParentCode, v))
+}
+
+// ParentCodeIn applies the In predicate on the "parent_code" field.
+func ParentCodeIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldParentCode, vs...))
+}
+
+// ParentCodeNotIn applies the NotIn predicate on the "parent_code" field.
+func ParentCodeNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldParentCode, vs...))
+}
+
+// ParentCodeGT applies the GT predicate on the "parent_code" field.
+func ParentCodeGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldParentCode, v))
+}
+
+// ParentCodeGTE applies the GTE predicate on the "parent_code" field.
+func ParentCodeGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldParentCode, v))
+}
+
+// ParentCodeLT applies the LT predicate on the "parent_code" field.
+func ParentCodeLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldParentCode, v))
+}
+
+// ParentCodeLTE applies the LTE predicate on the "parent_code" field.
+func ParentCodeLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldParentCode, v))
+}
+
+// ParentCodeContains applies the Contains predicate on the "parent_code" field.
+func ParentCodeContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldParentCode, v))
+}
+
+// ParentCodeHasPrefix applies the HasPrefix predicate on the "parent_code" field.
+func ParentCodeHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldParentCode, v))
+}
+
+// ParentCodeHasSuffix applies the HasSuffix predicate on the "parent_code" field.
+func ParentCodeHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldParentCode, v))
+}
+
+// ParentCodeIsNil applies the IsNil predicate on the "parent_code" field.
+func ParentCodeIsNil() predicate.Zone {
+	return predicate.Zone(sql.FieldIsNull(FieldParentCode))
+}
+
+// ParentCodeNotNil applies the NotNil predicate on the "parent_code" field.
+func ParentCodeNotNil() predicate.Zone {
+	return predicate.Zone(sql.FieldNotNull(FieldParentCode))
+}
+
+// ParentCodeEqualFold applies the EqualFold predicate on the "parent_code" field.
+func ParentCodeEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldParentCode, v))
+}
+
+// ParentCodeContainsFold applies the ContainsFold predicate on the "parent_code" field.
+func ParentCodeContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldParentCode, v))
+}
+
+// ZoneCodeEQ applies the EQ predicate on the "zone_code" field.
+func ZoneCodeEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeNEQ applies the NEQ predicate on the "zone_code" field.
+func ZoneCodeNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldZoneCode, v))
+}
+
+// ZoneCodeIn applies the In predicate on the "zone_code" field.
+func ZoneCodeIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeNotIn applies the NotIn predicate on the "zone_code" field.
+func ZoneCodeNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldZoneCode, vs...))
+}
+
+// ZoneCodeGT applies the GT predicate on the "zone_code" field.
+func ZoneCodeGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldZoneCode, v))
+}
+
+// ZoneCodeGTE applies the GTE predicate on the "zone_code" field.
+func ZoneCodeGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldZoneCode, v))
+}
+
+// ZoneCodeLT applies the LT predicate on the "zone_code" field.
+func ZoneCodeLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldZoneCode, v))
+}
+
+// ZoneCodeLTE applies the LTE predicate on the "zone_code" field.
+func ZoneCodeLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldZoneCode, v))
+}
+
+// ZoneCodeContains applies the Contains predicate on the "zone_code" field.
+func ZoneCodeContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldZoneCode, v))
+}
+
+// ZoneCodeHasPrefix applies the HasPrefix predicate on the "zone_code" field.
+func ZoneCodeHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldZoneCode, v))
+}
+
+// ZoneCodeHasSuffix applies the HasSuffix predicate on the "zone_code" field.
+func ZoneCodeHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldZoneCode, v))
+}
+
+// ZoneCodeEqualFold applies the EqualFold predicate on the "zone_code" field.
+func ZoneCodeEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldZoneCode, v))
+}
+
+// ZoneCodeContainsFold applies the ContainsFold predicate on the "zone_code" field.
+func ZoneCodeContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldZoneCode, v))
+}
+
+// ZoneNameEQ applies the EQ predicate on the "zone_name" field.
+func ZoneNameEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldZoneName, v))
+}
+
+// ZoneNameNEQ applies the NEQ predicate on the "zone_name" field.
+func ZoneNameNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldZoneName, v))
+}
+
+// ZoneNameIn applies the In predicate on the "zone_name" field.
+func ZoneNameIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldZoneName, vs...))
+}
+
+// ZoneNameNotIn applies the NotIn predicate on the "zone_name" field.
+func ZoneNameNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldZoneName, vs...))
+}
+
+// ZoneNameGT applies the GT predicate on the "zone_name" field.
+func ZoneNameGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldZoneName, v))
+}
+
+// ZoneNameGTE applies the GTE predicate on the "zone_name" field.
+func ZoneNameGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldZoneName, v))
+}
+
+// ZoneNameLT applies the LT predicate on the "zone_name" field.
+func ZoneNameLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldZoneName, v))
+}
+
+// ZoneNameLTE applies the LTE predicate on the "zone_name" field.
+func ZoneNameLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldZoneName, v))
+}
+
+// ZoneNameContains applies the Contains predicate on the "zone_name" field.
+func ZoneNameContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldZoneName, v))
+}
+
+// ZoneNameHasPrefix applies the HasPrefix predicate on the "zone_name" field.
+func ZoneNameHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldZoneName, v))
+}
+
+// ZoneNameHasSuffix applies the HasSuffix predicate on the "zone_name" field.
+func ZoneNameHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldZoneName, v))
+}
+
+// ZoneNameIsNil applies the IsNil predicate on the "zone_name" field.
+func ZoneNameIsNil() predicate.Zone {
+	return predicate.Zone(sql.FieldIsNull(FieldZoneName))
+}
+
+// ZoneNameNotNil applies the NotNil predicate on the "zone_name" field.
+func ZoneNameNotNil() predicate.Zone {
+	return predicate.Zone(sql.FieldNotNull(FieldZoneName))
+}
+
+// ZoneNameEqualFold applies the EqualFold predicate on the "zone_name" field.
+func ZoneNameEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldZoneName, v))
+}
+
+// ZoneNameContainsFold applies the ContainsFold predicate on the "zone_name" field.
+func ZoneNameContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldZoneName, v))
+}
+
+// DescriptionEQ applies the EQ predicate on the "description" field.
+func DescriptionEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldDescription, v))
+}
+
+// DescriptionNEQ applies the NEQ predicate on the "description" field.
+func DescriptionNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldDescription, v))
+}
+
+// DescriptionIn applies the In predicate on the "description" field.
+func DescriptionIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldDescription, vs...))
+}
+
+// DescriptionNotIn applies the NotIn predicate on the "description" field.
+func DescriptionNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldDescription, vs...))
+}
+
+// DescriptionGT applies the GT predicate on the "description" field.
+func DescriptionGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldDescription, v))
+}
+
+// DescriptionGTE applies the GTE predicate on the "description" field.
+func DescriptionGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldDescription, v))
+}
+
+// DescriptionLT applies the LT predicate on the "description" field.
+func DescriptionLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldDescription, v))
+}
+
+// DescriptionLTE applies the LTE predicate on the "description" field.
+func DescriptionLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldDescription, v))
+}
+
+// DescriptionContains applies the Contains predicate on the "description" field.
+func DescriptionContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldDescription, v))
+}
+
+// DescriptionHasPrefix applies the HasPrefix predicate on the "description" field.
+func DescriptionHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldDescription, v))
+}
+
+// DescriptionHasSuffix applies the HasSuffix predicate on the "description" field.
+func DescriptionHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldDescription, v))
+}
+
+// DescriptionIsNil applies the IsNil predicate on the "description" field.
+func DescriptionIsNil() predicate.Zone {
+	return predicate.Zone(sql.FieldIsNull(FieldDescription))
+}
+
+// DescriptionNotNil applies the NotNil predicate on the "description" field.
+func DescriptionNotNil() predicate.Zone {
+	return predicate.Zone(sql.FieldNotNull(FieldDescription))
+}
+
+// DescriptionEqualFold applies the EqualFold predicate on the "description" field.
+func DescriptionEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldDescription, v))
+}
+
+// DescriptionContainsFold applies the ContainsFold predicate on the "description" field.
+func DescriptionContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldDescription, v))
+}
+
+// ShelfNoEQ applies the EQ predicate on the "shelf_no" field.
+func ShelfNoEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldShelfNo, v))
+}
+
+// ShelfNoNEQ applies the NEQ predicate on the "shelf_no" field.
+func ShelfNoNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldShelfNo, v))
+}
+
+// ShelfNoIn applies the In predicate on the "shelf_no" field.
+func ShelfNoIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoNotIn applies the NotIn predicate on the "shelf_no" field.
+func ShelfNoNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldShelfNo, vs...))
+}
+
+// ShelfNoGT applies the GT predicate on the "shelf_no" field.
+func ShelfNoGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldShelfNo, v))
+}
+
+// ShelfNoGTE applies the GTE predicate on the "shelf_no" field.
+func ShelfNoGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldShelfNo, v))
+}
+
+// ShelfNoLT applies the LT predicate on the "shelf_no" field.
+func ShelfNoLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldShelfNo, v))
+}
+
+// ShelfNoLTE applies the LTE predicate on the "shelf_no" field.
+func ShelfNoLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldShelfNo, v))
+}
+
+// ShelfNoContains applies the Contains predicate on the "shelf_no" field.
+func ShelfNoContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldShelfNo, v))
+}
+
+// ShelfNoHasPrefix applies the HasPrefix predicate on the "shelf_no" field.
+func ShelfNoHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldShelfNo, v))
+}
+
+// ShelfNoHasSuffix applies the HasSuffix predicate on the "shelf_no" field.
+func ShelfNoHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldShelfNo, v))
+}
+
+// ShelfNoIsNil applies the IsNil predicate on the "shelf_no" field.
+func ShelfNoIsNil() predicate.Zone {
+	return predicate.Zone(sql.FieldIsNull(FieldShelfNo))
+}
+
+// ShelfNoNotNil applies the NotNil predicate on the "shelf_no" field.
+func ShelfNoNotNil() predicate.Zone {
+	return predicate.Zone(sql.FieldNotNull(FieldShelfNo))
+}
+
+// ShelfNoEqualFold applies the EqualFold predicate on the "shelf_no" field.
+func ShelfNoEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldShelfNo, v))
+}
+
+// ShelfNoContainsFold applies the ContainsFold predicate on the "shelf_no" field.
+func ShelfNoContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldShelfNo, v))
+}
+
+// LayerNoEQ applies the EQ predicate on the "layer_no" field.
+func LayerNoEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldLayerNo, v))
+}
+
+// LayerNoNEQ applies the NEQ predicate on the "layer_no" field.
+func LayerNoNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldLayerNo, v))
+}
+
+// LayerNoIn applies the In predicate on the "layer_no" field.
+func LayerNoIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldLayerNo, vs...))
+}
+
+// LayerNoNotIn applies the NotIn predicate on the "layer_no" field.
+func LayerNoNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldLayerNo, vs...))
+}
+
+// LayerNoGT applies the GT predicate on the "layer_no" field.
+func LayerNoGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldLayerNo, v))
+}
+
+// LayerNoGTE applies the GTE predicate on the "layer_no" field.
+func LayerNoGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldLayerNo, v))
+}
+
+// LayerNoLT applies the LT predicate on the "layer_no" field.
+func LayerNoLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldLayerNo, v))
+}
+
+// LayerNoLTE applies the LTE predicate on the "layer_no" field.
+func LayerNoLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldLayerNo, v))
+}
+
+// LayerNoContains applies the Contains predicate on the "layer_no" field.
+func LayerNoContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldLayerNo, v))
+}
+
+// LayerNoHasPrefix applies the HasPrefix predicate on the "layer_no" field.
+func LayerNoHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldLayerNo, v))
+}
+
+// LayerNoHasSuffix applies the HasSuffix predicate on the "layer_no" field.
+func LayerNoHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldLayerNo, v))
+}
+
+// LayerNoIsNil applies the IsNil predicate on the "layer_no" field.
+func LayerNoIsNil() predicate.Zone {
+	return predicate.Zone(sql.FieldIsNull(FieldLayerNo))
+}
+
+// LayerNoNotNil applies the NotNil predicate on the "layer_no" field.
+func LayerNoNotNil() predicate.Zone {
+	return predicate.Zone(sql.FieldNotNull(FieldLayerNo))
+}
+
+// LayerNoEqualFold applies the EqualFold predicate on the "layer_no" field.
+func LayerNoEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldLayerNo, v))
+}
+
+// LayerNoContainsFold applies the ContainsFold predicate on the "layer_no" field.
+func LayerNoContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldLayerNo, v))
+}
+
+// PositionNoEQ applies the EQ predicate on the "position_no" field.
+func PositionNoEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldPositionNo, v))
+}
+
+// PositionNoNEQ applies the NEQ predicate on the "position_no" field.
+func PositionNoNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldPositionNo, v))
+}
+
+// PositionNoIn applies the In predicate on the "position_no" field.
+func PositionNoIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldPositionNo, vs...))
+}
+
+// PositionNoNotIn applies the NotIn predicate on the "position_no" field.
+func PositionNoNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldPositionNo, vs...))
+}
+
+// PositionNoGT applies the GT predicate on the "position_no" field.
+func PositionNoGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldPositionNo, v))
+}
+
+// PositionNoGTE applies the GTE predicate on the "position_no" field.
+func PositionNoGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldPositionNo, v))
+}
+
+// PositionNoLT applies the LT predicate on the "position_no" field.
+func PositionNoLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldPositionNo, v))
+}
+
+// PositionNoLTE applies the LTE predicate on the "position_no" field.
+func PositionNoLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldPositionNo, v))
+}
+
+// PositionNoContains applies the Contains predicate on the "position_no" field.
+func PositionNoContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldPositionNo, v))
+}
+
+// PositionNoHasPrefix applies the HasPrefix predicate on the "position_no" field.
+func PositionNoHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldPositionNo, v))
+}
+
+// PositionNoHasSuffix applies the HasSuffix predicate on the "position_no" field.
+func PositionNoHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldPositionNo, v))
+}
+
+// PositionNoIsNil applies the IsNil predicate on the "position_no" field.
+func PositionNoIsNil() predicate.Zone {
+	return predicate.Zone(sql.FieldIsNull(FieldPositionNo))
+}
+
+// PositionNoNotNil applies the NotNil predicate on the "position_no" field.
+func PositionNoNotNil() predicate.Zone {
+	return predicate.Zone(sql.FieldNotNull(FieldPositionNo))
+}
+
+// PositionNoEqualFold applies the EqualFold predicate on the "position_no" field.
+func PositionNoEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldPositionNo, v))
+}
+
+// PositionNoContainsFold applies the ContainsFold predicate on the "position_no" field.
+func PositionNoContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldPositionNo, v))
+}
+
+// StatusEQ applies the EQ predicate on the "status" field.
+func StatusEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldStatus, v))
+}
+
+// StatusNEQ applies the NEQ predicate on the "status" field.
+func StatusNEQ(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldStatus, v))
+}
+
+// StatusIn applies the In predicate on the "status" field.
+func StatusIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldStatus, vs...))
+}
+
+// StatusNotIn applies the NotIn predicate on the "status" field.
+func StatusNotIn(vs ...string) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldStatus, vs...))
+}
+
+// StatusGT applies the GT predicate on the "status" field.
+func StatusGT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldStatus, v))
+}
+
+// StatusGTE applies the GTE predicate on the "status" field.
+func StatusGTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldStatus, v))
+}
+
+// StatusLT applies the LT predicate on the "status" field.
+func StatusLT(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldStatus, v))
+}
+
+// StatusLTE applies the LTE predicate on the "status" field.
+func StatusLTE(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldStatus, v))
+}
+
+// StatusContains applies the Contains predicate on the "status" field.
+func StatusContains(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContains(FieldStatus, v))
+}
+
+// StatusHasPrefix applies the HasPrefix predicate on the "status" field.
+func StatusHasPrefix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasPrefix(FieldStatus, v))
+}
+
+// StatusHasSuffix applies the HasSuffix predicate on the "status" field.
+func StatusHasSuffix(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldHasSuffix(FieldStatus, v))
+}
+
+// StatusEqualFold applies the EqualFold predicate on the "status" field.
+func StatusEqualFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldEqualFold(FieldStatus, v))
+}
+
+// StatusContainsFold applies the ContainsFold predicate on the "status" field.
+func StatusContainsFold(v string) predicate.Zone {
+	return predicate.Zone(sql.FieldContainsFold(FieldStatus, v))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...int64) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...int64) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...int64) predicate.Zone {
+	return predicate.Zone(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...int64) predicate.Zone {
+	return predicate.Zone(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v int64) predicate.Zone {
+	return predicate.Zone(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIsNil applies the IsNil predicate on the "updated_at" field.
+func UpdatedAtIsNil() predicate.Zone {
+	return predicate.Zone(sql.FieldIsNull(FieldUpdatedAt))
+}
+
+// UpdatedAtNotNil applies the NotNil predicate on the "updated_at" field.
+func UpdatedAtNotNil() predicate.Zone {
+	return predicate.Zone(sql.FieldNotNull(FieldUpdatedAt))
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Zone) predicate.Zone {
+	return predicate.Zone(sql.AndPredicates(predicates...))
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Zone) predicate.Zone {
+	return predicate.Zone(sql.OrPredicates(predicates...))
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Zone) predicate.Zone {
+	return predicate.Zone(sql.NotPredicates(p))
+}
diff --git a/bj_power_wms/zone/zone.go b/bj_power_wms/zone/zone.go
new file mode 100644
index 0000000..df8e4e8
--- /dev/null
+++ b/bj_power_wms/zone/zone.go
@@ -0,0 +1,152 @@
+// Code generated by ent, DO NOT EDIT.
+
+package zone
+
+import (
+	"entgo.io/ent/dialect/sql"
+)
+
+const (
+	// Label holds the string label denoting the zone type in the database.
+	Label = "zone"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldLevel holds the string denoting the level field in the database.
+	FieldLevel = "level"
+	// FieldCode holds the string denoting the code field in the database.
+	FieldCode = "code"
+	// FieldName holds the string denoting the name field in the database.
+	FieldName = "name"
+	// FieldParentCode holds the string denoting the parent_code field in the database.
+	FieldParentCode = "parent_code"
+	// FieldZoneCode holds the string denoting the zone_code field in the database.
+	FieldZoneCode = "zone_code"
+	// FieldZoneName holds the string denoting the zone_name field in the database.
+	FieldZoneName = "zone_name"
+	// FieldDescription holds the string denoting the description field in the database.
+	FieldDescription = "description"
+	// FieldShelfNo holds the string denoting the shelf_no field in the database.
+	FieldShelfNo = "shelf_no"
+	// FieldLayerNo holds the string denoting the layer_no field in the database.
+	FieldLayerNo = "layer_no"
+	// FieldPositionNo holds the string denoting the position_no field in the database.
+	FieldPositionNo = "position_no"
+	// FieldStatus holds the string denoting the status field in the database.
+	FieldStatus = "status"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// Table holds the table name of the zone in the database.
+	Table = "zones"
+)
+
+// Columns holds all SQL columns for zone fields.
+var Columns = []string{
+	FieldID,
+	FieldLevel,
+	FieldCode,
+	FieldName,
+	FieldParentCode,
+	FieldZoneCode,
+	FieldZoneName,
+	FieldDescription,
+	FieldShelfNo,
+	FieldLayerNo,
+	FieldPositionNo,
+	FieldStatus,
+	FieldCreatedAt,
+	FieldUpdatedAt,
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// DefaultStatus holds the default value on creation for the "status" field.
+	DefaultStatus string
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() int64
+	// DefaultUpdatedAt holds the default value on creation for the "updated_at" field.
+	DefaultUpdatedAt func() int64
+)
+
+// OrderOption defines the ordering options for the Zone queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByLevel orders the results by the level field.
+func ByLevel(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLevel, opts...).ToFunc()
+}
+
+// ByCode orders the results by the code field.
+func ByCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCode, opts...).ToFunc()
+}
+
+// ByName orders the results by the name field.
+func ByName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldName, opts...).ToFunc()
+}
+
+// ByParentCode orders the results by the parent_code field.
+func ByParentCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldParentCode, opts...).ToFunc()
+}
+
+// ByZoneCode orders the results by the zone_code field.
+func ByZoneCode(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldZoneCode, opts...).ToFunc()
+}
+
+// ByZoneName orders the results by the zone_name field.
+func ByZoneName(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldZoneName, opts...).ToFunc()
+}
+
+// ByDescription orders the results by the description field.
+func ByDescription(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDescription, opts...).ToFunc()
+}
+
+// ByShelfNo orders the results by the shelf_no field.
+func ByShelfNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldShelfNo, opts...).ToFunc()
+}
+
+// ByLayerNo orders the results by the layer_no field.
+func ByLayerNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLayerNo, opts...).ToFunc()
+}
+
+// ByPositionNo orders the results by the position_no field.
+func ByPositionNo(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPositionNo, opts...).ToFunc()
+}
+
+// ByStatus orders the results by the status field.
+func ByStatus(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldStatus, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}