QueryExecutor

abstract def adapter: MongoJavaDriverAdapter[MB, RB]

abstract def defaultWriteConcern: WriteConcern

abstract def optimizer: QueryOptimizer

abstract def readSerializer[M <: MB, R](meta: M, select: Option[MongoSelect[M, R]]): RogueReadSerializer[R]

abstract def writeSerializer(record: RB): RogueWriteSerializer[RB]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit def anyValIsFlattened[A <: AnyVal]: Flattened[A, A]

final def asInstanceOf[T0]: T0

implicit def booleanRFieldToModifyField[M](f: Field[Boolean, M]): ModifyField[Boolean, M]

def bulkDelete_!(implicit ev1: Required[State, Unselected with Unlimited with Unskipped], ev2: ShardingOk[M, State], ev3: !<:<[M, MongoDisallowed]): Unit

implicit def byteRFieldToModifyField[M](f: Field[Byte, M]): NumericModifyField[Byte, M]

implicit def charRFieldToModifyField[M](f: Field[Char, M]): ModifyField[Char, M]

def clone(): AnyRef

def count[M <: MB, State](query: Query[M, _, State], readPreference: Option[ReadPreference] = None)(implicit ev: ShardingOk[M, State], ev2: !<:<[M, MongoDisallowed]): Long

def countDistinct[M <: MB, V, State](query: Query[M, _, State], readPreference: Option[ReadPreference] = None)(field: (M) ⇒ Field[V, M])(implicit ev: ShardingOk[M, State], ev2: !<:<[M, MongoDisallowed]): Long

implicit val dateIsFlattened: Flattened[Date, Date]

implicit def dateRFieldToDateModifyField[M](f: Field[Date, M]): DateModifyField[M]

implicit def datetimeRFieldToDateModifyField[M](f: Field[DateTime, M]): DateTimeModifyField[M]

def distinct[M <: MB, V, State](query: Query[M, _, State], readPreference: Option[ReadPreference] = None)(field: (M) ⇒ Field[V, M])(implicit ev: ShardingOk[M, State], ev2: !<:<[M, MongoDisallowed]): Seq[V]

implicit def doubleRFieldToModifyField[M](f: Field[Double, M]): NumericModifyField[Double, M]

implicit def enumIsFlattened[A <: Value]: Flattened[A, A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def explain[M <: MB](query: Query[M, _, _]): String

def fetch[M <: MB, R, State](query: Query[M, R, State], readPreference: Option[ReadPreference] = None)(implicit ev: ShardingOk[M, State], ev2: !<:<[M, MongoDisallowed]): Seq[R]

def fetchBatch[M <: MB, R, T, State](query: Query[M, R, State], batchSize: Int, readPreference: Option[ReadPreference] = None)(f: (Seq[R]) ⇒ Seq[T])(implicit ev: ShardingOk[M, State], ev2: !<:<[M, MongoDisallowed]): Seq[T]

def fetchBatchList[M <: MB, R, T, State](query: Query[M, R, State], batchSize: Int, readPreference: Option[ReadPreference] = None)(f: (List[R]) ⇒ List[T])(implicit ev: ShardingOk[M, State], ev2: !<:<[M, MongoDisallowed]): List[T]

def fetchList[M <: MB, R, State](query: Query[M, R, State], readPreference: Option[ReadPreference] = None)(implicit ev: ShardingOk[M, State], ev2: !<:<[M, MongoDisallowed]): List[R]

def fetchOne[M <: MB, R, State, S2](query: Query[M, R, State], readPreference: Option[ReadPreference] = None, masterFallback: Boolean = false)(implicit ev1: AddLimit[State, S2], ev2: ShardingOk[M, S2], ev3: !<:<[M, MongoDisallowed]): Option[R]

def finalize(): Unit

def findAndDeleteOne[M <: MB, R, State](query: Query[M, R, State], writeConcern: WriteConcern = defaultWriteConcern)(implicit ev: RequireShardKey[M, State]): Option[R]

def findAndUpdateOne[M <: MB, R](query: FindAndModifyQuery[M, R], returnNew: Boolean = false, writeConcern: WriteConcern = defaultWriteConcern): Option[R]

def findAndUpsertOne[M <: MB, R](query: FindAndModifyQuery[M, R], returnNew: Boolean = false, writeConcern: WriteConcern = defaultWriteConcern): Option[R]

implicit def floatRFieldToModifyField[M](f: Field[Float, M]): NumericModifyField[Float, M]

def foreach[M <: MB, R, State](query: Query[M, R, State], readPreference: Option[ReadPreference] = None)(f: (R) ⇒ Unit)(implicit ev: ShardingOk[M, State], ev2: !<:<[M, MongoDisallowed]): Unit

final def getClass(): Class[_]

def hashCode(): Int

def insert[RecordType <: RB](record: RecordType, writeConcern: WriteConcern = defaultWriteConcern): RecordType

def insertAll[RecordType <: RB](records: Seq[RecordType], writeConcern: WriteConcern = defaultWriteConcern): Seq[RecordType]

implicit def intRFieldToModifyField[M](f: Field[Int, M]): NumericModifyField[Int, M]

final def isInstanceOf[T0]: Boolean

def iterate[S, M <: MB, R, State](query: Query[M, R, State], state: S, readPreference: Option[ReadPreference] = None)(handler: (S, Event[R]) ⇒ Command[S])(implicit ev: ShardingOk[M, State]): S

def iterateBatch[S, M <: MB, R, State](query: Query[M, R, State], batchSize: Int, state: S, readPreference: Option[ReadPreference] = None)(handler: (S, Event[Seq[R]]) ⇒ Command[S])(implicit ev: ShardingOk[M, State]): S

implicit def longRFieldToModifyField[M, F <: Long](f: Field[F, M]): NumericModifyField[F, M]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

implicit val objectIdIsFlattened: Flattened[ObjectId, ObjectId]

implicit def objectidRFieldToModifyField[M, F <: ObjectId](f: Field[F, M]): ModifyField[F, M]

implicit def rArrayFieldToArrayModifyField[M, F](f: Field[Array[F], M])(implicit arg0: BSONType[F]): ArrayModifyField[F, M]

implicit def rSeqFieldToSeqModifyField[M, F](f: Field[Seq[F], M])(implicit arg0: BSONType[F]): SeqModifyField[F, M]

implicit def rStringsListFieldToStringsListQueryField[M](f: Field[List[String], M]): StringsListQueryField[M]

implicit def rbooleanFieldtoQueryField[M](f: Field[Boolean, M]): QueryField[Boolean, M]

implicit def rbyteFieldtoNumericQueryField[M](f: Field[Byte, M]): NumericQueryField[Byte, M]

implicit def rcharFieldtoQueryField[M](f: Field[Char, M]): QueryField[Char, M]

implicit def rdateFieldToDateQueryField[M](f: Field[Date, M]): DateQueryField[M]

implicit def rdatetimeFieldToDateQueryField[M](f: Field[DateTime, M]): DateTimeQueryField[M]

implicit def rdbobjectFieldToQueryField[M](f: Field[DBObject, M]): QueryField[DBObject, M]

implicit def rdoubleFieldtoNumericQueryField[M](f: Field[Double, M]): NumericQueryField[Double, M]

implicit def recursiveFlattenArray[A, B](implicit ev: Flattened[A, B]): Flattened[Array[A], B]

implicit def recursiveFlattenList[A, B](implicit ev: Flattened[A, B]): Flattened[List[A], B]

implicit def recursiveFlattenSeq[A, B](implicit ev: Flattened[A, B]): Flattened[Seq[A], B]

def remove[RecordType <: RB](record: RecordType, writeConcern: WriteConcern = defaultWriteConcern): RecordType

implicit def renumNameFieldToEnumNameQueryField[M, F <: Value](f: Field[F, M]): EnumNameQueryField[M, F]

implicit def renumerationFieldToEnumerationModifyField[M, F <: Value](f: Field[F, M]): EnumerationModifyField[M, F]

implicit def renumerationListFieldToEnumerationListModifyField[M, F <: Value](f: Field[List[F], M]): EnumerationListModifyField[F, M]

implicit def renumerationListFieldToEnumerationListQueryField[M, F <: Value](f: Field[List[F], M]): EnumerationListQueryField[F, M]

implicit def rfieldToSafeModifyField[M, F](f: Field[F, M]): SafeModifyField[F, M]

ModifyField implicits

implicit def rfloatFieldtoNumericQueryField[M](f: Field[Float, M]): NumericQueryField[Float, M]

implicit def rintFieldtoNumericQueryField[M](f: Field[Int, M]): NumericQueryField[Int, M]

implicit def rjlongFieldtoNumericQueryField[F <: Long, M](f: Field[F, M]): NumericQueryField[F, M]

implicit def rlatLongFieldToGeoQueryField[M](f: Field[LatLong, M]): GeoQueryField[M]

implicit def rlatLongFieldToGeoQueryModifyField[M](f: Field[LatLong, M]): GeoModifyField[M]

implicit def rlistFieldToListModifyField[M, F](f: Field[List[F], M])(implicit arg0: BSONType[F]): ListModifyField[F, M]

implicit def rlistFieldToListQueryField[M, F](f: Field[List[F], M])(implicit arg0: BSONType[F]): ListQueryField[F, M]

implicit def rlongFieldtoNumericQueryField[F <: Long, M](f: Field[F, M]): NumericQueryField[F, M]

implicit def rmapFieldToMapModifyField[M, F](f: Field[Map[String, F], M]): MapModifyField[F, M]

implicit def rmapFieldToMapQueryField[M, F](f: Field[Map[String, F], M]): MapQueryField[F, M]

implicit def robjectIdFieldToObjectIdQueryField[F <: ObjectId, M](f: Field[F, M]): ObjectIdQueryField[F, M]

implicit def roptionalFieldToSelectField[M, V](f: OptionalField[V, M]): SelectField[Option[V], M]

implicit def rrequiredFieldToSelectField[M, V](f: RequiredField[V, M]): SelectField[V, M]

implicit def rseqFieldToSeqQueryField[M, F](f: Field[Seq[F], M])(implicit arg0: BSONType[F]): SeqQueryField[F, M]

implicit def rshortFieldtoNumericQueryField[M](f: Field[Short, M]): NumericQueryField[Short, M]

implicit def rstringFieldToStringQueryField[F <: String, M](f: Field[F, M]): StringQueryField[F, M]

def save[RecordType <: RB](record: RecordType, writeConcern: WriteConcern = defaultWriteConcern): RecordType

implicit def shortRFieldToModifyField[M](f: Field[Short, M]): NumericModifyField[Short, M]

implicit val stringIsFlattened: Flattened[String, String]

implicit def stringRFieldToModifyField[M, F <: String](f: Field[F, M]): ModifyField[F, M]

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

def toString(): String

def updateMulti[M <: MB, State](query: ModifyQuery[M, State], writeConcern: WriteConcern = defaultWriteConcern): Unit

def updateOne[M <: MB, State](query: ModifyQuery[M, State], writeConcern: WriteConcern = defaultWriteConcern)(implicit ev: RequireShardKey[M, State]): Unit

def upsertOne[M <: MB, State](query: ModifyQuery[M, State], writeConcern: WriteConcern = defaultWriteConcern)(implicit ev: RequireShardKey[M, State]): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit