// Code generated by ent, DO NOT EDIT.

package order

import (
	"entgo.io/ent/dialect/sql"
	"github.com/cloudwego/biz-demo/open-payment-platform/internal/payment/infrastructure/ent/predicate"
)

// ID filters vertices based on their ID field.
func ID(id int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldID), id))
	})
}

// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldID), id))
	})
}

// IDIn applies the In predicate on the ID field.
func IDIn(ids ...int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		v := make([]any, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.In(s.C(FieldID), v...))
	})
}

// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		v := make([]any, len(ids))
		for i := range v {
			v[i] = ids[i]
		}
		s.Where(sql.NotIn(s.C(FieldID), v...))
	})
}

// IDGT applies the GT predicate on the ID field.
func IDGT(id int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldID), id))
	})
}

// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldID), id))
	})
}

// IDLT applies the LT predicate on the ID field.
func IDLT(id int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldID), id))
	})
}

// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id int) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldID), id))
	})
}

// MerchantID applies equality check predicate on the "merchant_id" field. It's identical to MerchantIDEQ.
func MerchantID(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMerchantID), v))
	})
}

// Channel applies equality check predicate on the "channel" field. It's identical to ChannelEQ.
func Channel(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldChannel), v))
	})
}

// PayWay applies equality check predicate on the "pay_way" field. It's identical to PayWayEQ.
func PayWay(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPayWay), v))
	})
}

// OutOrderNo applies equality check predicate on the "out_order_no" field. It's identical to OutOrderNoEQ.
func OutOrderNo(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOutOrderNo), v))
	})
}

// TotalAmount applies equality check predicate on the "total_amount" field. It's identical to TotalAmountEQ.
func TotalAmount(v uint64) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTotalAmount), v))
	})
}

// Body applies equality check predicate on the "body" field. It's identical to BodyEQ.
func Body(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldBody), v))
	})
}

// OrderStatus applies equality check predicate on the "order_status" field. It's identical to OrderStatusEQ.
func OrderStatus(v int8) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOrderStatus), v))
	})
}

// AuthCode applies equality check predicate on the "auth_code" field. It's identical to AuthCodeEQ.
func AuthCode(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAuthCode), v))
	})
}

// WxAppid applies equality check predicate on the "wx_appid" field. It's identical to WxAppidEQ.
func WxAppid(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWxAppid), v))
	})
}

// SubOpenid applies equality check predicate on the "sub_openid" field. It's identical to SubOpenidEQ.
func SubOpenid(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSubOpenid), v))
	})
}

// JumpURL applies equality check predicate on the "jump_url" field. It's identical to JumpURLEQ.
func JumpURL(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldJumpURL), v))
	})
}

// NotifyURL applies equality check predicate on the "notify_url" field. It's identical to NotifyURLEQ.
func NotifyURL(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldNotifyURL), v))
	})
}

// ClientIP applies equality check predicate on the "client_ip" field. It's identical to ClientIPEQ.
func ClientIP(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldClientIP), v))
	})
}

// Attach applies equality check predicate on the "attach" field. It's identical to AttachEQ.
func Attach(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAttach), v))
	})
}

// OrderExpiration applies equality check predicate on the "order_expiration" field. It's identical to OrderExpirationEQ.
func OrderExpiration(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOrderExpiration), v))
	})
}

// ExtendParams applies equality check predicate on the "extend_params" field. It's identical to ExtendParamsEQ.
func ExtendParams(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldExtendParams), v))
	})
}

// MerchantIDEQ applies the EQ predicate on the "merchant_id" field.
func MerchantIDEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldMerchantID), v))
	})
}

// MerchantIDNEQ applies the NEQ predicate on the "merchant_id" field.
func MerchantIDNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldMerchantID), v))
	})
}

// MerchantIDIn applies the In predicate on the "merchant_id" field.
func MerchantIDIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldMerchantID), v...))
	})
}

// MerchantIDNotIn applies the NotIn predicate on the "merchant_id" field.
func MerchantIDNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldMerchantID), v...))
	})
}

// MerchantIDGT applies the GT predicate on the "merchant_id" field.
func MerchantIDGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldMerchantID), v))
	})
}

// MerchantIDGTE applies the GTE predicate on the "merchant_id" field.
func MerchantIDGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldMerchantID), v))
	})
}

// MerchantIDLT applies the LT predicate on the "merchant_id" field.
func MerchantIDLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldMerchantID), v))
	})
}

// MerchantIDLTE applies the LTE predicate on the "merchant_id" field.
func MerchantIDLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldMerchantID), v))
	})
}

// MerchantIDContains applies the Contains predicate on the "merchant_id" field.
func MerchantIDContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldMerchantID), v))
	})
}

// MerchantIDHasPrefix applies the HasPrefix predicate on the "merchant_id" field.
func MerchantIDHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldMerchantID), v))
	})
}

// MerchantIDHasSuffix applies the HasSuffix predicate on the "merchant_id" field.
func MerchantIDHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldMerchantID), v))
	})
}

// MerchantIDEqualFold applies the EqualFold predicate on the "merchant_id" field.
func MerchantIDEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldMerchantID), v))
	})
}

// MerchantIDContainsFold applies the ContainsFold predicate on the "merchant_id" field.
func MerchantIDContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldMerchantID), v))
	})
}

// ChannelEQ applies the EQ predicate on the "channel" field.
func ChannelEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldChannel), v))
	})
}

// ChannelNEQ applies the NEQ predicate on the "channel" field.
func ChannelNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldChannel), v))
	})
}

// ChannelIn applies the In predicate on the "channel" field.
func ChannelIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldChannel), v...))
	})
}

// ChannelNotIn applies the NotIn predicate on the "channel" field.
func ChannelNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldChannel), v...))
	})
}

// ChannelGT applies the GT predicate on the "channel" field.
func ChannelGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldChannel), v))
	})
}

// ChannelGTE applies the GTE predicate on the "channel" field.
func ChannelGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldChannel), v))
	})
}

// ChannelLT applies the LT predicate on the "channel" field.
func ChannelLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldChannel), v))
	})
}

// ChannelLTE applies the LTE predicate on the "channel" field.
func ChannelLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldChannel), v))
	})
}

// ChannelContains applies the Contains predicate on the "channel" field.
func ChannelContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldChannel), v))
	})
}

// ChannelHasPrefix applies the HasPrefix predicate on the "channel" field.
func ChannelHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldChannel), v))
	})
}

// ChannelHasSuffix applies the HasSuffix predicate on the "channel" field.
func ChannelHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldChannel), v))
	})
}

// ChannelEqualFold applies the EqualFold predicate on the "channel" field.
func ChannelEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldChannel), v))
	})
}

// ChannelContainsFold applies the ContainsFold predicate on the "channel" field.
func ChannelContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldChannel), v))
	})
}

// PayWayEQ applies the EQ predicate on the "pay_way" field.
func PayWayEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldPayWay), v))
	})
}

// PayWayNEQ applies the NEQ predicate on the "pay_way" field.
func PayWayNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldPayWay), v))
	})
}

// PayWayIn applies the In predicate on the "pay_way" field.
func PayWayIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldPayWay), v...))
	})
}

// PayWayNotIn applies the NotIn predicate on the "pay_way" field.
func PayWayNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldPayWay), v...))
	})
}

// PayWayGT applies the GT predicate on the "pay_way" field.
func PayWayGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldPayWay), v))
	})
}

// PayWayGTE applies the GTE predicate on the "pay_way" field.
func PayWayGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldPayWay), v))
	})
}

// PayWayLT applies the LT predicate on the "pay_way" field.
func PayWayLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldPayWay), v))
	})
}

// PayWayLTE applies the LTE predicate on the "pay_way" field.
func PayWayLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldPayWay), v))
	})
}

// PayWayContains applies the Contains predicate on the "pay_way" field.
func PayWayContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldPayWay), v))
	})
}

// PayWayHasPrefix applies the HasPrefix predicate on the "pay_way" field.
func PayWayHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldPayWay), v))
	})
}

// PayWayHasSuffix applies the HasSuffix predicate on the "pay_way" field.
func PayWayHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldPayWay), v))
	})
}

// PayWayEqualFold applies the EqualFold predicate on the "pay_way" field.
func PayWayEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldPayWay), v))
	})
}

// PayWayContainsFold applies the ContainsFold predicate on the "pay_way" field.
func PayWayContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldPayWay), v))
	})
}

// OutOrderNoEQ applies the EQ predicate on the "out_order_no" field.
func OutOrderNoEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoNEQ applies the NEQ predicate on the "out_order_no" field.
func OutOrderNoNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoIn applies the In predicate on the "out_order_no" field.
func OutOrderNoIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldOutOrderNo), v...))
	})
}

// OutOrderNoNotIn applies the NotIn predicate on the "out_order_no" field.
func OutOrderNoNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldOutOrderNo), v...))
	})
}

// OutOrderNoGT applies the GT predicate on the "out_order_no" field.
func OutOrderNoGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoGTE applies the GTE predicate on the "out_order_no" field.
func OutOrderNoGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoLT applies the LT predicate on the "out_order_no" field.
func OutOrderNoLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoLTE applies the LTE predicate on the "out_order_no" field.
func OutOrderNoLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoContains applies the Contains predicate on the "out_order_no" field.
func OutOrderNoContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoHasPrefix applies the HasPrefix predicate on the "out_order_no" field.
func OutOrderNoHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoHasSuffix applies the HasSuffix predicate on the "out_order_no" field.
func OutOrderNoHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoEqualFold applies the EqualFold predicate on the "out_order_no" field.
func OutOrderNoEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldOutOrderNo), v))
	})
}

// OutOrderNoContainsFold applies the ContainsFold predicate on the "out_order_no" field.
func OutOrderNoContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldOutOrderNo), v))
	})
}

// TotalAmountEQ applies the EQ predicate on the "total_amount" field.
func TotalAmountEQ(v uint64) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldTotalAmount), v))
	})
}

// TotalAmountNEQ applies the NEQ predicate on the "total_amount" field.
func TotalAmountNEQ(v uint64) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldTotalAmount), v))
	})
}

// TotalAmountIn applies the In predicate on the "total_amount" field.
func TotalAmountIn(vs ...uint64) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldTotalAmount), v...))
	})
}

// TotalAmountNotIn applies the NotIn predicate on the "total_amount" field.
func TotalAmountNotIn(vs ...uint64) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldTotalAmount), v...))
	})
}

// TotalAmountGT applies the GT predicate on the "total_amount" field.
func TotalAmountGT(v uint64) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldTotalAmount), v))
	})
}

// TotalAmountGTE applies the GTE predicate on the "total_amount" field.
func TotalAmountGTE(v uint64) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldTotalAmount), v))
	})
}

// TotalAmountLT applies the LT predicate on the "total_amount" field.
func TotalAmountLT(v uint64) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldTotalAmount), v))
	})
}

// TotalAmountLTE applies the LTE predicate on the "total_amount" field.
func TotalAmountLTE(v uint64) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldTotalAmount), v))
	})
}

// BodyEQ applies the EQ predicate on the "body" field.
func BodyEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldBody), v))
	})
}

// BodyNEQ applies the NEQ predicate on the "body" field.
func BodyNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldBody), v))
	})
}

// BodyIn applies the In predicate on the "body" field.
func BodyIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldBody), v...))
	})
}

// BodyNotIn applies the NotIn predicate on the "body" field.
func BodyNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldBody), v...))
	})
}

// BodyGT applies the GT predicate on the "body" field.
func BodyGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldBody), v))
	})
}

// BodyGTE applies the GTE predicate on the "body" field.
func BodyGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldBody), v))
	})
}

// BodyLT applies the LT predicate on the "body" field.
func BodyLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldBody), v))
	})
}

// BodyLTE applies the LTE predicate on the "body" field.
func BodyLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldBody), v))
	})
}

// BodyContains applies the Contains predicate on the "body" field.
func BodyContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldBody), v))
	})
}

// BodyHasPrefix applies the HasPrefix predicate on the "body" field.
func BodyHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldBody), v))
	})
}

// BodyHasSuffix applies the HasSuffix predicate on the "body" field.
func BodyHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldBody), v))
	})
}

// BodyEqualFold applies the EqualFold predicate on the "body" field.
func BodyEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldBody), v))
	})
}

// BodyContainsFold applies the ContainsFold predicate on the "body" field.
func BodyContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldBody), v))
	})
}

// OrderStatusEQ applies the EQ predicate on the "order_status" field.
func OrderStatusEQ(v int8) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOrderStatus), v))
	})
}

// OrderStatusNEQ applies the NEQ predicate on the "order_status" field.
func OrderStatusNEQ(v int8) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldOrderStatus), v))
	})
}

// OrderStatusIn applies the In predicate on the "order_status" field.
func OrderStatusIn(vs ...int8) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldOrderStatus), v...))
	})
}

// OrderStatusNotIn applies the NotIn predicate on the "order_status" field.
func OrderStatusNotIn(vs ...int8) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldOrderStatus), v...))
	})
}

// OrderStatusGT applies the GT predicate on the "order_status" field.
func OrderStatusGT(v int8) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldOrderStatus), v))
	})
}

// OrderStatusGTE applies the GTE predicate on the "order_status" field.
func OrderStatusGTE(v int8) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldOrderStatus), v))
	})
}

// OrderStatusLT applies the LT predicate on the "order_status" field.
func OrderStatusLT(v int8) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldOrderStatus), v))
	})
}

// OrderStatusLTE applies the LTE predicate on the "order_status" field.
func OrderStatusLTE(v int8) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldOrderStatus), v))
	})
}

// AuthCodeEQ applies the EQ predicate on the "auth_code" field.
func AuthCodeEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAuthCode), v))
	})
}

// AuthCodeNEQ applies the NEQ predicate on the "auth_code" field.
func AuthCodeNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldAuthCode), v))
	})
}

// AuthCodeIn applies the In predicate on the "auth_code" field.
func AuthCodeIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldAuthCode), v...))
	})
}

// AuthCodeNotIn applies the NotIn predicate on the "auth_code" field.
func AuthCodeNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldAuthCode), v...))
	})
}

// AuthCodeGT applies the GT predicate on the "auth_code" field.
func AuthCodeGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldAuthCode), v))
	})
}

// AuthCodeGTE applies the GTE predicate on the "auth_code" field.
func AuthCodeGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldAuthCode), v))
	})
}

// AuthCodeLT applies the LT predicate on the "auth_code" field.
func AuthCodeLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldAuthCode), v))
	})
}

// AuthCodeLTE applies the LTE predicate on the "auth_code" field.
func AuthCodeLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldAuthCode), v))
	})
}

// AuthCodeContains applies the Contains predicate on the "auth_code" field.
func AuthCodeContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldAuthCode), v))
	})
}

// AuthCodeHasPrefix applies the HasPrefix predicate on the "auth_code" field.
func AuthCodeHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldAuthCode), v))
	})
}

// AuthCodeHasSuffix applies the HasSuffix predicate on the "auth_code" field.
func AuthCodeHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldAuthCode), v))
	})
}

// AuthCodeEqualFold applies the EqualFold predicate on the "auth_code" field.
func AuthCodeEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldAuthCode), v))
	})
}

// AuthCodeContainsFold applies the ContainsFold predicate on the "auth_code" field.
func AuthCodeContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldAuthCode), v))
	})
}

// WxAppidEQ applies the EQ predicate on the "wx_appid" field.
func WxAppidEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldWxAppid), v))
	})
}

// WxAppidNEQ applies the NEQ predicate on the "wx_appid" field.
func WxAppidNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldWxAppid), v))
	})
}

// WxAppidIn applies the In predicate on the "wx_appid" field.
func WxAppidIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldWxAppid), v...))
	})
}

// WxAppidNotIn applies the NotIn predicate on the "wx_appid" field.
func WxAppidNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldWxAppid), v...))
	})
}

// WxAppidGT applies the GT predicate on the "wx_appid" field.
func WxAppidGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldWxAppid), v))
	})
}

// WxAppidGTE applies the GTE predicate on the "wx_appid" field.
func WxAppidGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldWxAppid), v))
	})
}

// WxAppidLT applies the LT predicate on the "wx_appid" field.
func WxAppidLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldWxAppid), v))
	})
}

// WxAppidLTE applies the LTE predicate on the "wx_appid" field.
func WxAppidLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldWxAppid), v))
	})
}

// WxAppidContains applies the Contains predicate on the "wx_appid" field.
func WxAppidContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldWxAppid), v))
	})
}

// WxAppidHasPrefix applies the HasPrefix predicate on the "wx_appid" field.
func WxAppidHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldWxAppid), v))
	})
}

// WxAppidHasSuffix applies the HasSuffix predicate on the "wx_appid" field.
func WxAppidHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldWxAppid), v))
	})
}

// WxAppidEqualFold applies the EqualFold predicate on the "wx_appid" field.
func WxAppidEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldWxAppid), v))
	})
}

// WxAppidContainsFold applies the ContainsFold predicate on the "wx_appid" field.
func WxAppidContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldWxAppid), v))
	})
}

// SubOpenidEQ applies the EQ predicate on the "sub_openid" field.
func SubOpenidEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidNEQ applies the NEQ predicate on the "sub_openid" field.
func SubOpenidNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidIn applies the In predicate on the "sub_openid" field.
func SubOpenidIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldSubOpenid), v...))
	})
}

// SubOpenidNotIn applies the NotIn predicate on the "sub_openid" field.
func SubOpenidNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldSubOpenid), v...))
	})
}

// SubOpenidGT applies the GT predicate on the "sub_openid" field.
func SubOpenidGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidGTE applies the GTE predicate on the "sub_openid" field.
func SubOpenidGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidLT applies the LT predicate on the "sub_openid" field.
func SubOpenidLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidLTE applies the LTE predicate on the "sub_openid" field.
func SubOpenidLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidContains applies the Contains predicate on the "sub_openid" field.
func SubOpenidContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidHasPrefix applies the HasPrefix predicate on the "sub_openid" field.
func SubOpenidHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidHasSuffix applies the HasSuffix predicate on the "sub_openid" field.
func SubOpenidHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidEqualFold applies the EqualFold predicate on the "sub_openid" field.
func SubOpenidEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldSubOpenid), v))
	})
}

// SubOpenidContainsFold applies the ContainsFold predicate on the "sub_openid" field.
func SubOpenidContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldSubOpenid), v))
	})
}

// JumpURLEQ applies the EQ predicate on the "jump_url" field.
func JumpURLEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldJumpURL), v))
	})
}

// JumpURLNEQ applies the NEQ predicate on the "jump_url" field.
func JumpURLNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldJumpURL), v))
	})
}

// JumpURLIn applies the In predicate on the "jump_url" field.
func JumpURLIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldJumpURL), v...))
	})
}

// JumpURLNotIn applies the NotIn predicate on the "jump_url" field.
func JumpURLNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldJumpURL), v...))
	})
}

// JumpURLGT applies the GT predicate on the "jump_url" field.
func JumpURLGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldJumpURL), v))
	})
}

// JumpURLGTE applies the GTE predicate on the "jump_url" field.
func JumpURLGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldJumpURL), v))
	})
}

// JumpURLLT applies the LT predicate on the "jump_url" field.
func JumpURLLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldJumpURL), v))
	})
}

// JumpURLLTE applies the LTE predicate on the "jump_url" field.
func JumpURLLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldJumpURL), v))
	})
}

// JumpURLContains applies the Contains predicate on the "jump_url" field.
func JumpURLContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldJumpURL), v))
	})
}

// JumpURLHasPrefix applies the HasPrefix predicate on the "jump_url" field.
func JumpURLHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldJumpURL), v))
	})
}

// JumpURLHasSuffix applies the HasSuffix predicate on the "jump_url" field.
func JumpURLHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldJumpURL), v))
	})
}

// JumpURLEqualFold applies the EqualFold predicate on the "jump_url" field.
func JumpURLEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldJumpURL), v))
	})
}

// JumpURLContainsFold applies the ContainsFold predicate on the "jump_url" field.
func JumpURLContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldJumpURL), v))
	})
}

// NotifyURLEQ applies the EQ predicate on the "notify_url" field.
func NotifyURLEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLNEQ applies the NEQ predicate on the "notify_url" field.
func NotifyURLNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLIn applies the In predicate on the "notify_url" field.
func NotifyURLIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldNotifyURL), v...))
	})
}

// NotifyURLNotIn applies the NotIn predicate on the "notify_url" field.
func NotifyURLNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldNotifyURL), v...))
	})
}

// NotifyURLGT applies the GT predicate on the "notify_url" field.
func NotifyURLGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLGTE applies the GTE predicate on the "notify_url" field.
func NotifyURLGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLLT applies the LT predicate on the "notify_url" field.
func NotifyURLLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLLTE applies the LTE predicate on the "notify_url" field.
func NotifyURLLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLContains applies the Contains predicate on the "notify_url" field.
func NotifyURLContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLHasPrefix applies the HasPrefix predicate on the "notify_url" field.
func NotifyURLHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLHasSuffix applies the HasSuffix predicate on the "notify_url" field.
func NotifyURLHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLEqualFold applies the EqualFold predicate on the "notify_url" field.
func NotifyURLEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldNotifyURL), v))
	})
}

// NotifyURLContainsFold applies the ContainsFold predicate on the "notify_url" field.
func NotifyURLContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldNotifyURL), v))
	})
}

// ClientIPEQ applies the EQ predicate on the "client_ip" field.
func ClientIPEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldClientIP), v))
	})
}

// ClientIPNEQ applies the NEQ predicate on the "client_ip" field.
func ClientIPNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldClientIP), v))
	})
}

// ClientIPIn applies the In predicate on the "client_ip" field.
func ClientIPIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldClientIP), v...))
	})
}

// ClientIPNotIn applies the NotIn predicate on the "client_ip" field.
func ClientIPNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldClientIP), v...))
	})
}

// ClientIPGT applies the GT predicate on the "client_ip" field.
func ClientIPGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldClientIP), v))
	})
}

// ClientIPGTE applies the GTE predicate on the "client_ip" field.
func ClientIPGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldClientIP), v))
	})
}

// ClientIPLT applies the LT predicate on the "client_ip" field.
func ClientIPLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldClientIP), v))
	})
}

// ClientIPLTE applies the LTE predicate on the "client_ip" field.
func ClientIPLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldClientIP), v))
	})
}

// ClientIPContains applies the Contains predicate on the "client_ip" field.
func ClientIPContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldClientIP), v))
	})
}

// ClientIPHasPrefix applies the HasPrefix predicate on the "client_ip" field.
func ClientIPHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldClientIP), v))
	})
}

// ClientIPHasSuffix applies the HasSuffix predicate on the "client_ip" field.
func ClientIPHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldClientIP), v))
	})
}

// ClientIPEqualFold applies the EqualFold predicate on the "client_ip" field.
func ClientIPEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldClientIP), v))
	})
}

// ClientIPContainsFold applies the ContainsFold predicate on the "client_ip" field.
func ClientIPContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldClientIP), v))
	})
}

// AttachEQ applies the EQ predicate on the "attach" field.
func AttachEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldAttach), v))
	})
}

// AttachNEQ applies the NEQ predicate on the "attach" field.
func AttachNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldAttach), v))
	})
}

// AttachIn applies the In predicate on the "attach" field.
func AttachIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldAttach), v...))
	})
}

// AttachNotIn applies the NotIn predicate on the "attach" field.
func AttachNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldAttach), v...))
	})
}

// AttachGT applies the GT predicate on the "attach" field.
func AttachGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldAttach), v))
	})
}

// AttachGTE applies the GTE predicate on the "attach" field.
func AttachGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldAttach), v))
	})
}

// AttachLT applies the LT predicate on the "attach" field.
func AttachLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldAttach), v))
	})
}

// AttachLTE applies the LTE predicate on the "attach" field.
func AttachLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldAttach), v))
	})
}

// AttachContains applies the Contains predicate on the "attach" field.
func AttachContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldAttach), v))
	})
}

// AttachHasPrefix applies the HasPrefix predicate on the "attach" field.
func AttachHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldAttach), v))
	})
}

// AttachHasSuffix applies the HasSuffix predicate on the "attach" field.
func AttachHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldAttach), v))
	})
}

// AttachEqualFold applies the EqualFold predicate on the "attach" field.
func AttachEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldAttach), v))
	})
}

// AttachContainsFold applies the ContainsFold predicate on the "attach" field.
func AttachContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldAttach), v))
	})
}

// OrderExpirationEQ applies the EQ predicate on the "order_expiration" field.
func OrderExpirationEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationNEQ applies the NEQ predicate on the "order_expiration" field.
func OrderExpirationNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationIn applies the In predicate on the "order_expiration" field.
func OrderExpirationIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldOrderExpiration), v...))
	})
}

// OrderExpirationNotIn applies the NotIn predicate on the "order_expiration" field.
func OrderExpirationNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldOrderExpiration), v...))
	})
}

// OrderExpirationGT applies the GT predicate on the "order_expiration" field.
func OrderExpirationGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationGTE applies the GTE predicate on the "order_expiration" field.
func OrderExpirationGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationLT applies the LT predicate on the "order_expiration" field.
func OrderExpirationLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationLTE applies the LTE predicate on the "order_expiration" field.
func OrderExpirationLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationContains applies the Contains predicate on the "order_expiration" field.
func OrderExpirationContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationHasPrefix applies the HasPrefix predicate on the "order_expiration" field.
func OrderExpirationHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationHasSuffix applies the HasSuffix predicate on the "order_expiration" field.
func OrderExpirationHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationEqualFold applies the EqualFold predicate on the "order_expiration" field.
func OrderExpirationEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldOrderExpiration), v))
	})
}

// OrderExpirationContainsFold applies the ContainsFold predicate on the "order_expiration" field.
func OrderExpirationContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldOrderExpiration), v))
	})
}

// ExtendParamsEQ applies the EQ predicate on the "extend_params" field.
func ExtendParamsEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EQ(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsNEQ applies the NEQ predicate on the "extend_params" field.
func ExtendParamsNEQ(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NEQ(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsIn applies the In predicate on the "extend_params" field.
func ExtendParamsIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.In(s.C(FieldExtendParams), v...))
	})
}

// ExtendParamsNotIn applies the NotIn predicate on the "extend_params" field.
func ExtendParamsNotIn(vs ...string) predicate.Order {
	v := make([]any, len(vs))
	for i := range v {
		v[i] = vs[i]
	}
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.NotIn(s.C(FieldExtendParams), v...))
	})
}

// ExtendParamsGT applies the GT predicate on the "extend_params" field.
func ExtendParamsGT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GT(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsGTE applies the GTE predicate on the "extend_params" field.
func ExtendParamsGTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.GTE(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsLT applies the LT predicate on the "extend_params" field.
func ExtendParamsLT(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LT(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsLTE applies the LTE predicate on the "extend_params" field.
func ExtendParamsLTE(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.LTE(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsContains applies the Contains predicate on the "extend_params" field.
func ExtendParamsContains(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.Contains(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsHasPrefix applies the HasPrefix predicate on the "extend_params" field.
func ExtendParamsHasPrefix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasPrefix(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsHasSuffix applies the HasSuffix predicate on the "extend_params" field.
func ExtendParamsHasSuffix(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.HasSuffix(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsEqualFold applies the EqualFold predicate on the "extend_params" field.
func ExtendParamsEqualFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.EqualFold(s.C(FieldExtendParams), v))
	})
}

// ExtendParamsContainsFold applies the ContainsFold predicate on the "extend_params" field.
func ExtendParamsContainsFold(v string) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s.Where(sql.ContainsFold(s.C(FieldExtendParams), v))
	})
}

// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Order) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for _, p := range predicates {
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Order) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		s1 := s.Clone().SetP(nil)
		for i, p := range predicates {
			if i > 0 {
				s1.Or()
			}
			p(s1)
		}
		s.Where(s1.P())
	})
}

// Not applies the not operator on the given predicate.
func Not(p predicate.Order) predicate.Order {
	return predicate.Order(func(s *sql.Selector) {
		p(s.Not())
	})
}
