Extension

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (Extension, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val Case: scala.slick.lifted.Case.type

val Compiled: scala.slick.lifted.Compiled.type

val Database: DatabaseFactoryDef

def DatabaseConfig(db: Database): Read with Write

Creates a context that uses the same database for reads and writes.

val ForeignKeyAction: scala.slick.model.ForeignKeyAction.type

val Functions: scala.slick.lifted.Functions.type

val LiteralColumn: scala.slick.lifted.LiteralColumn.type

val MappedColumnType: P.MappedJdbcType.type

def MasterSlaveConfig(master: Database, slave: Database): Read with Write

Creates a context that has separate master and slave databases.

val Parameters: scala.slick.lifted.Parameters.type

val Query: scala.slick.lifted.Query.type

val Sequence: P.Sequence.type

val SimpleBinaryOperator: scala.slick.lifted.SimpleBinaryOperator.type

val SimpleExpression: scala.slick.lifted.SimpleExpression.type

val SimpleFunction: scala.slick.lifted.SimpleFunction.type

val SimpleLiteral: scala.slick.lifted.SimpleLiteral.type

object SlickAction extends ActionCompanion

val TableQuery: scala.slick.lifted.TableQuery.type

val TupleMethods: scala.slick.util.TupleMethods.type

implicit def anyColumnExtensionMethods[B1](c: scala.slick.lifted.Column[B1])(implicit arg0: BaseTypedType[B1]): AnyExtensionMethods

implicit def anyOptionColumnExtensionMethods[B1](c: scala.slick.lifted.Column[Option[B1]]): AnyExtensionMethods

implicit def anyOptionValueExtensionMethods[B1](v: Option[B1])(implicit arg0: TypedType[B1]): AnyExtensionMethods

implicit final def anyToToShapedValue[T](value: T): ToShapedValue[T]

implicit def anyValueExtensionMethods[B1](v: B1)(implicit arg0: BaseTypedType[B1]): AnyExtensionMethods

final def asInstanceOf[T0]: T0

implicit def bigDecimalColumnType: BigDecimalJdbcType

implicit def blobColumnType: BlobJdbcType

implicit def booleanColumnExtensionMethods(c: scala.slick.lifted.Column[Boolean]): BooleanColumnExtensionMethods[Boolean]

implicit def booleanColumnType: BooleanJdbcType

implicit def booleanOptionColumnExtensionMethods(c: scala.slick.lifted.Column[Option[Boolean]]): BooleanColumnExtensionMethods[Option[Boolean]]

implicit def byteArrayColumnType: ByteArrayJdbcType

implicit def byteColumnType: ByteJdbcType

implicit def charColumnType: CharJdbcType

implicit def clobColumnType: ClobJdbcType

def clone(): AnyRef

implicit def columnExtensionMethods[B1](c: scala.slick.lifted.Column[B1])(implicit arg0: BaseTypedType[B1]): PlainColumnExtensionMethods[B1]

implicit def columnToOptionColumn[T](c: Column[T])(implicit arg0: BaseTypedType[T]): Column[Option[T]]

implicit def columnToOrdered[T](c: Column[T]): ColumnOrdered[T]

implicit def dateColumnType: DateJdbcType

implicit def ddlToDDLInvoker(d: P.DDL): DDLInvokerAction

implicit def doubleColumnType: DoubleJdbcType

def ensuring(cond: (Extension) ⇒ Boolean, msg: ⇒ Any): Extension

def ensuring(cond: (Extension) ⇒ Boolean): Extension

def ensuring(cond: Boolean, msg: ⇒ Any): Extension

def ensuring(cond: Boolean): Extension

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

implicit def floatColumnType: FloatJdbcType

def formatted(fmtstr: String): String

final def getClass(): Class[_]

def hashCode(): Int

implicit def intColumnType: IntJdbcType

final def isInstanceOf[T0]: Boolean

implicit def isomorphicType[A, B](implicit iso: scala.slick.lifted.Isomorphism[A, B], ct: ClassTag[A], jt: P.BaseColumnType[B]): P.BaseColumnType[A]

implicit def jdbcFastPathExtensionMethods[T, P](mp: MappedProjection[T, P]): P.JdbcFastPathExtensionMethods[T, P]

implicit def longColumnType: LongJdbcType

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit def numericColumnExtensionMethods[B1](c: scala.slick.lifted.Column[B1])(implicit tm: BaseTypedType[B1] with NumericTypedType): NumericColumnExtensionMethods[B1, B1]

implicit def numericOptionColumnExtensionMethods[B1](c: scala.slick.lifted.Column[Option[B1]])(implicit tm: BaseTypedType[B1] with NumericTypedType): NumericColumnExtensionMethods[B1, Option[B1]]

implicit def optionColumnExtensionMethods[B1](c: scala.slick.lifted.Column[Option[B1]]): OptionColumnExtensionMethods[B1]

implicit def productQueryToUpdateInvoker[T, C[_]](q: Query[_ <: Rep[T], T, C]): UpdateInvokerAction[T]

implicit def queryToAppliedQueryInvoker[U, C[_]](q: Query[_, U, C]): QueryInvokerAction[U]

implicit def queryToDeleteInvoker[C[_]](q: Query[_ <: Table[_], _, C]): DeleteInvokerAction

implicit def queryToInsertInvoker[U, C[_]](q: Query[_, U, C]): InsertInvokerAction[U]

implicit def queryToUpdateInvoker[U, C[_]](q: Query[_, U, C]): UpdateInvokerAction[U]

implicit def recordToQueryExecutor[M, R](q: M)(implicit shape: Shape[_ <: FlatShapeLevel, M, R, _]): QueryExecutorAction[R]

implicit def repToQueryExecutor[U](rep: Rep[U]): QueryExecutorAction[U]

implicit def runnableCompiledToAppliedQueryInvoker[RU, C[_]](c: RunnableCompiled[_ <: Query[_, _, C], C[RU]]): QueryInvokerAction[RU]

implicit def runnableCompiledToDeleteInvoker[RU, C[_]](c: RunnableCompiled[_ <: Query[_, _, C], C[RU]]): DeleteInvokerAction

implicit def runnableCompiledToQueryExecutor[RU](c: RunnableCompiled[_, RU]): QueryExecutorAction[RU]

implicit def runnableCompiledToUpdateInvoker[RU, C[_]](c: RunnableCompiled[_ <: Query[_, _, C], C[RU]]): UpdateInvokerAction[RU]

def sameConnection[T <: SlickConfig, R](action: SlickAction[T, R])(implicit db: ReadWriteSelect[T]): SlickAction[T, R]

Runs the action and all enclosed actions in the same JDBC connection.

implicit def selectRead[T <: Read](implicit ev: !<:[T, Write]): ReadWriteSelect[T]

Implicitly select read database for Actions that need Read configuration

implicit def selectWrite[T <: Write]: ReadWriteSelect[T]

Implicitly select write database for Actions that need Write configuration.

implicit def shortColumnType: ShortJdbcType

implicit def singleColumnQueryExtensionMethods[B1, C[_]](q: scala.slick.lifted.Query[scala.slick.lifted.Column[B1], _, C])(implicit arg0: BaseTypedType[B1]): SingleColumnQueryExtensionMethods[B1, B1, C]

implicit def singleOptionColumnQueryExtensionMethods[B1, C[_]](q: scala.slick.lifted.Query[scala.slick.lifted.Column[Option[B1]], _, C]): SingleColumnQueryExtensionMethods[B1, Option[B1], C]

implicit val slickDriver: driver.type

implicit def streamableCompiledToInsertInvoker[EU](c: StreamableCompiled[_, _, EU]): InsertInvokerAction[EU]

implicit def stringColumnExtensionMethods(c: scala.slick.lifted.Column[String]): StringColumnExtensionMethods[String]

implicit def stringColumnType: StringJdbcType

implicit def stringOptionColumnExtensionMethods(c: scala.slick.lifted.Column[Option[String]]): StringColumnExtensionMethods[Option[String]]

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

implicit def tableQueryToTableQueryExtensionMethods[T <: Table[_], U](q: Query[T, U, Seq] with TableQuery[T]): P.TableQueryExtensionMethods[T, U]

implicit def timeColumnType: TimeJdbcType

implicit def timestampColumnType: TimestampJdbcType

def toString(): String

def transaction[T <: SlickConfig, R](action: SlickAction[T, R])(implicit db: ReadWriteSelect[T]): SlickAction[T, R]

Runs the action and all enclosed actions in a transaction.

def unsafe[T <: SlickConfig](implicit db: ReadWriteSelect[T]): unsafe[T]

Helper for unsafe actions to allow partial type-inference

implicit def uuidColumnType: UUIDJdbcType

implicit def valueToConstColumn[T](v: T)(implicit arg0: TypedType[T]): scala.slick.lifted.LiteralColumn[T]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def →[B](y: B): (Extension, B)

val self: Any

val self: Any

def x: Extension

def x: Extension