ValidUntil

abstract def canEqual(that: Any): Boolean

abstract def productArity: Int

abstract def productElement(n: Int): Any

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

lazy val _companion: ProductModelCompanion[ValidUntil.this.type]

var _isNewRecord: Boolean

def afterCreate(): Unit

def afterDelete(): Unit

def afterSave(): Unit

def afterUpdate(): Unit

final def asInstanceOf[T0]: T0

def asJson(onlyFields: String*): JValue

def asJson(onlyFields: List[String]): JValue

def asJson: JValue

macro def assign(data: Map[String, Any]): ValidUntil.this.type

macro def assign(data: (String, Any)*): ValidUntil.this.type

def assignFormValues(data: Map[String, String]): ValidUntil.this.type

def beforeCreate(): Unit

def beforeDelete(): Unit

def beforeSave(): Unit

def beforeUpdate(): Unit

def beforeValidation(): Unit

def belongsTo[T <: AR](foreignKey: String)(implicit m: ClassTag[T]): com.github.aselab.activerecord.ActiveRecord.BelongsToAssociation[ValidUntil.this.type, T]

def belongsTo[T <: AR](implicit m: ClassTag[T]): com.github.aselab.activerecord.ActiveRecord.BelongsToAssociation[ValidUntil.this.type, T]

def clearErrors(): Unit

def clone(): AnyRef

def create(validate: Boolean): ValidUntil.this.type

def create: ValidUntil.this.type

implicit def date2timestamp(date: Option[Date]): Option[Timestamp]

implicit def date2timestamp(date: Date): Timestamp

def delete(): Boolean

def deleteEither(): Either[Errors, ValidUntil.this.type]

def doCreate(): Boolean

def doDelete(): Boolean

def doUpdate(): Boolean

def doValidate(): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val errors: Errors

def fieldErrors: Seq[ValidationError]

def finalize(): Unit

def formErrors: Seq[ValidationError]

def fromJValue(jvalue: JValue): ValidUntil.this.type

def fromJson(json: String): ValidUntil.this.type

final def getClass(): Class[_]

def globalErrors: Seq[ValidationError]

def hasAndBelongsToMany[T <: ActiveRecord](conditions: Map[String, Any])(implicit m: ClassTag[T]): com.github.aselab.activerecord.ActiveRecord.HasAndBelongsToManyAssociation[ValidUntil.this.type, T]

def hasAndBelongsToMany[T <: ActiveRecord](implicit m: ClassTag[T]): com.github.aselab.activerecord.ActiveRecord.HasAndBelongsToManyAssociation[ValidUntil.this.type, T]

def hasError(name: String): Boolean

def hasErrors: Boolean

def hasMany[T <: AR](conditions: Map[String, Any], foreignKey: String)(implicit m: ClassTag[T]): com.github.aselab.activerecord.ActiveRecord.HasManyAssociation[ValidUntil.this.type, T]

def hasMany[T <: AR](implicit m: ClassTag[T]): com.github.aselab.activerecord.ActiveRecord.HasManyAssociation[ValidUntil.this.type, T]

def hasManyThrough[T <: AR, I <: AR](through: com.github.aselab.activerecord.ActiveRecord.CollectionAssociation[ValidUntil.this.type, I], conditions: Map[String, Any], foreignKey: String)(implicit m1: ClassTag[T], m2: ClassTag[I]): com.github.aselab.activerecord.ActiveRecord.HasManyThroughAssociation[ValidUntil.this.type, T, I]

def hasOne[T <: AR](conditions: Map[String, Any], foreignKey: String)(implicit m: ClassTag[T]): com.github.aselab.activerecord.ActiveRecord.HasOneAssociation[ValidUntil.this.type, T]

def hasOne[T <: AR](implicit m: ClassTag[T]): com.github.aselab.activerecord.ActiveRecord.HasOneAssociation[ValidUntil.this.type, T]

def hasOneThrough[T <: AR, I <: AR](through: com.github.aselab.activerecord.ActiveRecord.SingularAssociation[ValidUntil.this.type, I], conditions: Map[String, Any], foreignKey: String)(implicit m1: ClassTag[T], m2: ClassTag[I]): com.github.aselab.activerecord.ActiveRecord.HasOneThroughAssociation[ValidUntil.this.type, T, I]

def hashCode(): Int

val id: Long

def invalidEntity[A <: ValidUntil]: (A) ⇒ BinaryOperatorNodeLogicalBoolean

def isDeleted: Boolean

def isEntityValid[A <: ValidUntil]: (A) ⇒ LogicalBoolean

final def isInstanceOf[T0]: Boolean

def isNewRecord: Boolean

def isPersisted: Boolean

def isValid: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def now: Timestamp

def productIterator: Iterator[Any]

def productPrefix: String

lazy val recordCompanion: ActiveRecordBaseCompanion[Long, ValidUntil.this.type]

def recordInDatabase: Option[ValidUntil.this.type]

def save(throws: Boolean, validate: Boolean): Boolean

def save(): Boolean

def saveEither: Either[Errors, ValidUntil.this.type]

def saveWithoutValidation(): Boolean

def serializedValue(value: Any): Any

final def synchronized[T0](arg0: ⇒ T0): T0

implicit def timestamp2date(timestamp: Option[Timestamp]): Option[Date]

implicit def timestamp2date(timestamp: Timestamp): Date

def toFieldType(value: Any, fieldInfo: FieldInfo): Any

def toFormValues(prefix: Option[String]): Map[String, String]

def toFormValues: Map[String, String]

def toJson(onlyFields: String*): String

def toJson(onlyFields: List[String]): String

def toJson: String

def toMap: Map[String, Any]

def toMap(onlyFields: String*): Map[String, Any]

def toMap(onlyFields: List[String]): Map[String, Any]

def toSerialized(map: Map[String, Any]): Map[String, Any]

def toSerializedMap(onlyFields: List[String]): Map[String, Any]

def toSerializedMap: Map[String, Any]

def toString(): String

def unsafeAssign(data: Map[String, Any]): ValidUntil.this.type

def unsafeAssign(data: Map[String, Any], assignFunc: (Any, FieldInfo) ⇒ Any): ValidUntil.this.type

def update(validate: Boolean): ValidUntil.this.type

def update: ValidUntil.this.type

def validOnly: Map[String, Null]

Note: valid until detects only NULL, if it will be invalid in future, that would not work

var validUntil: Option[Timestamp]

flag when the entity was deleted

def validate(): Boolean

def validity(validity: Boolean): (ValidUntil) ⇒ LogicalBoolean

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit