SoftDeleteWithBooleanFeature

abstract def extract(rs: WrappedResultSet, n: scalikejdbc.SQLInterpolation.ResultName[Entity]): Entity

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def appendToDefaultScope(part: ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): Unit

def appendToDefaultScopeWithDefaultAlias(part: ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): Unit

def apply(rs: WrappedResultSet): Entity

def apply(a: Alias[Entity])(rs: WrappedResultSet): Entity

def as(provider: scalikejdbc.SQLInterpolation.QuerySQLSyntaxProvider[scalikejdbc.SQLInterpolation.SQLSyntaxSupport[Entity], Entity]): scalikejdbc.SQLInterpolation.TableAsAliasSQLSyntax

final def asInstanceOf[T0]: T0

val associations: LinkedHashSet[Association[_]]

val autoSession: DBSession

def belongsTo[A](right: AssociationsFeature[A], merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithAlias[A](right: (AssociationsFeature[A], Alias[A]), merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithAliasAndFk[A](right: (AssociationsFeature[A], Alias[A]), fk: String, merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def belongsToWithFk[A](right: AssociationsFeature[A], fk: String, merge: (Entity, Option[A]) ⇒ Entity): BelongsToAssociation[Entity]

def clone(): AnyRef

def column: scalikejdbc.SQLInterpolation.ColumnName[Entity]

def columnNames: Seq[String]

def columns: Seq[String]

def connectionPool: ConnectionPool

def connectionPoolName: Any

def countAll()(implicit s: DBSession = autoSession): Long

def countBy(where: scalikejdbc.SQLInterpolation.SQLSyntax)(implicit s: DBSession = autoSession): Long

def createAlias(name: String): Alias[Entity]

def createJoinDefinition(joinType: JoinType, left: (AssociationsFeature[_], Alias[_]), right: (AssociationsFeature[_], Alias[_]), on: scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def createWithAttributes(strongParameters: PermittedStrongParameters)(implicit s: DBSession = autoSession): Long

def createWithNamedValues(namedValues: (scalikejdbc.SQLInterpolation.SQLSyntax, Any)*)(implicit s: DBSession = autoSession): Long

def defaultAlias: Alias[Entity]

val defaultBelongsToExtractors: LinkedHashSet[BelongsToExtractor[Entity]]

val defaultHasOneExtractors: LinkedHashSet[HasOneExtractor[Entity]]

val defaultJoinDefinitions: LinkedHashSet[JoinDefinition[_]]

val defaultOneToManyExtractors: LinkedHashSet[ToManyExtractor[Entity]]

lazy val defaultScopeWithDefaultAlias: Option[scalikejdbc.SQLInterpolation.SQLSyntax]

lazy val defaultScopeWithoutAlias: Option[scalikejdbc.SQLInterpolation.SQLSyntax]

def defaultSelectQuery: scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity]

def deleteById(id: Long)(implicit s: DBSession): Unit

def delimiterForResultName: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extractBelongsTo[That](mapper: AssociationsFeature[That], fk: String, alias: Alias[That], merge: (Entity, Option[That]) ⇒ Entity): BelongsToExtractor[Entity]

def extractHasOne[That](mapper: AssociationsFeature[That], fk: String, alias: Alias[That], merge: (Entity, Option[That]) ⇒ Entity): HasOneExtractor[Entity]

def extractOneToMany[M1](mapper: AssociationsFeature[M1], alias: Alias[M1], merge: (Entity, Seq[M1]) ⇒ Entity): ToManyExtractor[Entity]

def extractOneToManyWithDefaults[M1](mapper: AssociationsFeature[M1], merge: (Entity, Seq[M1]) ⇒ Entity): ToManyExtractor[Entity]

One-to-Many relationship definition.

object Member extends RelationshipFeature[Member] {
oneToMany[Group](
  mapper = Group,
  merge = (m, c) => m.copy(company = c)
)
}

def extractWithOneToOneTables(rs: WrappedResultSet, belongsToExtractors: Set[BelongsToExtractor[Entity]], hasOneExtractors: Set[HasOneExtractor[Entity]]): Entity

def finalize(): Unit

def findAll(limit: Int = 100, offset: Int = 0)(implicit s: DBSession = autoSession): List[Entity]

def findAllBy(where: scalikejdbc.SQLInterpolation.SQLSyntax, limit: Int = 100, offset: Int = 0)(implicit s: DBSession = autoSession): List[Entity]

def findAllByIds(ids: Long*)(implicit s: DBSession = autoSession): List[Entity]

def findById(id: Long)(implicit s: DBSession = autoSession): Option[Entity]

def forceUpperCase: Boolean

final def getClass(): Class[_]

def getSimpleName(obj: Any): String

def getTypedValueFromStrongParameter(fieldName: String, value: Any, paramType: ParamType): Option[Any]

def hasMany[M](many: (AssociationsFeature[M], Alias[M]), on: (Alias[Entity], Alias[M]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Seq[M]) ⇒ Entity): HasManyAssociation[Entity]

def hasManyThrough[M1, M2](through: (AssociationsFeature[M1], Alias[M1]), throughOn: (Alias[Entity], Alias[M1]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax, many: (AssociationsFeature[M2], Alias[M2]), on: (Alias[M1], Alias[M2]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax, merge: (Entity, Seq[M2]) ⇒ Entity): HasManyAssociation[Entity]

def hasManyThrough[M2](through: AssociationsFeature[_], many: AssociationsFeature[M2], merge: (Entity, Seq[M2]) ⇒ Entity): HasManyAssociation[Entity]

def hasOne[A](right: AssociationsFeature[A], merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithAlias[A](right: (AssociationsFeature[A], Alias[A]), merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithAliasAndFk[A](right: (AssociationsFeature[A], Alias[A]), fk: String, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hasOneWithFk[A](right: AssociationsFeature[A], fk: String, merge: (Entity, Option[A]) ⇒ Entity): HasOneAssociation[Entity]

def hashCode(): Int

def innerJoin[Left](left: (AssociationsFeature[Left], Alias[Left]), right: (AssociationsFeature[_], Alias[_]), on: (Alias[Left], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def innerJoin(right: (AssociationsFeature[_], Alias[_]), on: (Alias[Entity], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def innerJoinWithDefaults[Left](left: AssociationsFeature[Left], right: AssociationsFeature[_], on: (Alias[Left], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def innerJoinWithDefaults(right: AssociationsFeature[_], on: (Alias[Entity], Alias[Any]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def innerJoinWithDefaults(right: AssociationsFeature[_], on: scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

val isDeletedFieldName: String

final def isInstanceOf[T0]: Boolean

def join[Left](left: (AssociationsFeature[Left], Alias[Left]), right: (AssociationsFeature[_], Alias[_]), on: (Alias[Left], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def join(right: (AssociationsFeature[_], Alias[_]), on: (Alias[Entity], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def joinWithDefaults[Left](left: AssociationsFeature[Left], right: AssociationsFeature[_], on: (Alias[Left], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def joinWithDefaults(right: AssociationsFeature[_], on: (Alias[Entity], Alias[Any]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def joinWithDefaults(right: AssociationsFeature[_], on: scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[Entity]

def joins(associations: Association[_]*): CRUDFeatureWithAssociations[Entity]

def leftJoin(left: (AssociationsFeature[_], Alias[_]), right: (AssociationsFeature[_], Alias[_]), on: (Alias[_], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def leftJoin(right: (AssociationsFeature[_], Alias[_]), on: (Alias[Entity], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def leftJoinWithDefaults(left: AssociationsFeature[_], right: AssociationsFeature[_], on: (Alias[_], Alias[_]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def leftJoinWithDefaults(right: AssociationsFeature[_], on: (Alias[Entity], Alias[Any]) ⇒ scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

def leftJoinWithDefaults(right: AssociationsFeature[_], on: scalikejdbc.SQLInterpolation.SQLSyntax): JoinDefinition[_]

val logger: Logger

def nameConverters: Map[String, String]

def namedValuesForCreation(strongParameters: PermittedStrongParameters): Seq[(scalikejdbc.SQLInterpolation.SQLSyntax, Any)]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prepareDefaultScopeWithDefaultAlias(): Unit

def prepareDefaultScopeWithoutAlias(): Unit

def primaryKeyName: String

def selectQuery: scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity]

def selectQueryWithAssociations(sql: scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity], belongsToAssociations: Set[BelongsToAssociation[Entity]], hasOneAssociations: Set[HasOneAssociation[Entity]], hasManyAssociations: Set[HasManyAssociation[Entity]]): scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity]

def setAsByDefault(extractor: ToManyExtractor[Entity]): Unit

def setAsByDefault(extractor: HasOneExtractor[Entity]): Unit

def setAsByDefault(extractor: BelongsToExtractor[Entity]): Unit

def singleSelectQuery: scalikejdbc.SQLInterpolation.SelectSQLBuilder[Entity]

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

def syntax(name: String): scalikejdbc.SQLInterpolation.QuerySQLSyntaxProvider[scalikejdbc.SQLInterpolation.SQLSyntaxSupport[Entity], Entity]

def syntax: scalikejdbc.SQLInterpolation.QuerySQLSyntaxProvider[scalikejdbc.SQLInterpolation.SQLSyntaxSupport[Entity], Entity]

def table: scalikejdbc.SQLInterpolation.TableDefSQLSyntax

def tableName: String

def toDefaultForeignKeyName[A](mapper: AssociationsFeature[A]): String

def toString(): String

def updateById(id: Long): UpdateOperationBuilder

val useAutoIncrementPrimaryKey: Boolean

def useShortenedResultName: Boolean

def useSnakeCaseColumnName: Boolean

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withAlias[A](name: String)(op: (Alias[Entity]) ⇒ A): A

def withAlias[A](op: (Alias[Entity]) ⇒ A): A

def withColumns[A](op: (scalikejdbc.SQLInterpolation.ColumnName[Entity]) ⇒ A): A

def withExtractor(sql: SQL[Entity, NoExtractor], belongsToAssociations: Set[BelongsToAssociation[Entity]], hasOneAssociations: Set[HasOneAssociation[Entity]], oneToManyAssociations: Set[HasManyAssociation[Entity]]): SQL[Entity, HasExtractor]

def withExtractor(sql: SQL[Entity, NoExtractor]): SQL[Entity, HasExtractor]