JSONCollection

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

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

final def ==(arg0: Any): Boolean

val BatchCommands: JSONBatchCommands.type

object ImplicitlyDocumentProducer

implicit def PackIdentityReader: Reader[Document]

implicit def PackIdentityWriter: Writer[Document]

def aggregate[T](firstOperator: PipelineOperator, otherOperators: List[PipelineOperator], cursor: Option[commands.JSONAggregationFramework.Cursor], explain: Boolean, allowDiskUse: Boolean, bypassDocumentValidation: Boolean, readConcern: Option[ReadConcern], readPreference: ReadPreference)(implicit ec: ExecutionContext, reader: Reader[T], cf: CursorFlattener[Cursor]): Cursor[T]

def aggregate(firstOperator: PipelineOperator, otherOperators: List[PipelineOperator], explain: Boolean, allowDiskUse: Boolean, bypassDocumentValidation: Boolean, readConcern: Option[ReadConcern])(implicit ec: ExecutionContext): Future[commands.JSONAggregationFramework.AggregationResult]

def aggregate1[T](firstOperator: PipelineOperator, otherOperators: List[PipelineOperator], explain: Boolean, allowDiskUse: Boolean, bypassDocumentValidation: Boolean, readConcern: Option[ReadConcern], readPreference: ReadPreference, batchSize: Option[Int])(implicit ec: ExecutionContext, reader: Reader[T], cf: CursorFlattener[Cursor]): Cursor[T]

def aggregateWith[T](explain: Boolean, allowDiskUse: Boolean, bypassDocumentValidation: Boolean, readConcern: Option[ReadConcern], readPreference: ReadPreference, batchSize: Option[Int])(f: (AggregationFramework) ⇒ (PipelineOperator, List[PipelineOperator]))(implicit ec: ExecutionContext, reader: Reader[T], cf: CursorFlattener[Cursor]): Cursor[T]

def as[C <: Collection](failoverStrategy: FailoverStrategy)(implicit producer: CollectionProducer[C]): C

final def asInstanceOf[T0]: T0

def bulkInsert(documents: Stream[Document], ordered: Boolean, writeConcern: WriteConcern, bulkSize: Int, bulkByteSize: Int)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

def bulkInsert(documents: Stream[Document], ordered: Boolean, writeConcern: WriteConcern)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

def bulkInsert(documents: Stream[Document], ordered: Boolean)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

def bulkInsert(ordered: Boolean, writeConcern: WriteConcern, bulkSize: Int, bulkByteSize: Int)(documents: ImplicitlyDocumentProducer*)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

def bulkInsert(ordered: Boolean, writeConcern: WriteConcern)(documents: ImplicitlyDocumentProducer*)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

def bulkInsert(ordered: Boolean)(documents: ImplicitlyDocumentProducer*)(implicit ec: ExecutionContext): Future[MultiBulkWriteResult]

def clone(): AnyRef

def convertToCapped(size: Long, maxDocuments: Option[Int])(implicit ec: ExecutionContext): Future[Unit]

def count[H](selector: Option[Document], limit: Int, skip: Int, hint: Option[H])(implicit h: (H) ⇒ JSONBatchCommands.JSONCountCommand.Hint, ec: ExecutionContext): Future[Int]

def create(autoIndexId: Boolean)(implicit ec: ExecutionContext): Future[Unit]

def createCapped(size: Long, maxDocuments: Option[Int], autoIndexId: Boolean)(implicit ec: ExecutionContext): Future[Unit]

val db: DB

def distinct[T, M[_] <: Iterable[_]](key: String, selector: Option[Document], readConcern: ReadConcern)(implicit reader: NarrowValueReader[T], ec: ExecutionContext, cbf: CanBuildFrom[M[_], T, M[T]]): Future[M[T]]

def drop(failIfNotFound: Boolean)(implicit ec: ExecutionContext): Future[Boolean]

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

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

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

def ensuring(cond: Boolean): JSONCollection

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val failoverStrategy: FailoverStrategy

def finalize(): Unit

def find[S, P](selector: S, projection: P)(implicit swriter: Writer[S], pwriter: Writer[P]): GenericQueryBuilder[pack.type]

def find[S](selector: S)(implicit swriter: Writer[S]): GenericQueryBuilder[pack.type]

def findAndModify[S](selector: S, modifier: commands.JSONFindAndModifyCommand.Modify, sort: Option[Document], fields: Option[Document])(implicit swriter: Writer[S], ec: ExecutionContext): Future[commands.JSONFindAndModifyCommand.FindAndModifyResult]

def findAndRemove[S](selector: S, sort: Option[Document], fields: Option[Document])(implicit swriter: Writer[S], ec: ExecutionContext): Future[commands.JSONFindAndModifyCommand.FindAndModifyResult]

def findAndUpdate[S, T](selector: S, update: T, fetchNewObject: Boolean, upsert: Boolean, sort: Option[Document], fields: Option[Document])(implicit swriter: Writer[S], writer: Writer[T], ec: ExecutionContext): Future[commands.JSONFindAndModifyCommand.FindAndModifyResult]

def formatted(fmtstr: String): String

def fullCollectionName: String

def genericQueryBuilder: GenericQueryBuilder[JSONSerializationPack.type]

final def getClass(): Class[_]

def hashCode(): Int

def indexesManager(implicit ec: ExecutionContext): CollectionIndexesManager

def insert[T](document: T, writeConcern: WriteConcern)(implicit writer: Writer[T], ec: ExecutionContext): Future[WriteResult]

final def isInstanceOf[T0]: Boolean

val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val pack: JSONSerializationPack.type

val readPreference: ReadPreference

def remove[S](selector: S, writeConcern: WriteConcern, firstMatchOnly: Boolean)(implicit swriter: Writer[S], ec: ExecutionContext): Future[WriteResult]

lazy val removeModifier: commands.JSONFindAndModifyCommand.Remove.type

def rename(to: String, dropExisting: Boolean)(implicit ec: ExecutionContext): Future[Unit]

def runCommand[C <: CollectionCommand](command: C)(implicit writer: Writer[ResolvedCollectionCommand[C]]): CursorFetcher[pack.type, Cursor]

def runCommand[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R], readPreference: ReadPreference)(implicit writer: Writer[ResolvedCollectionCommand[C]], reader: Reader[R], ec: ExecutionContext): Future[R]

def runValueCommand[A <: AnyVal, R <: BoxedAnyVal[A], C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R with BoxedAnyVal[A]], rp: ReadPreference)(implicit writer: Writer[ResolvedCollectionCommand[C]], reader: Reader[R], ec: ExecutionContext): Future[A]

def runWithResponse[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R], readPreference: ReadPreference)(implicit writer: Writer[ResolvedCollectionCommand[C]], reader: Reader[R], ec: ExecutionContext): Future[ResponseResult[R]]

def runner: CommandWithPackRunner[pack.type]

def sibling[C <: Collection](name: String, failoverStrategy: FailoverStrategy)(implicit producer: CollectionProducer[C]): C

def stats(scale: Int)(implicit ec: ExecutionContext): Future[CollStatsResult]

def stats()(implicit ec: ExecutionContext): Future[CollStatsResult]

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

def toString(): String

def update[S, T](selector: S, update: T, writeConcern: WriteConcern, upsert: Boolean, multi: Boolean)(implicit swriter: Writer[S], writer: Writer[T], ec: ExecutionContext): Future[UpdateWriteResult]

def updateModifier[U](update: U, fetchNewObject: Boolean, upsert: Boolean)(implicit updateWriter: Writer[U]): commands.JSONFindAndModifyCommand.Update

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def watchFailure[T](future: ⇒ Future[T]): Future[T]

def withReadPreference(pref: ReadPreference): JSONCollection

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

def drop()(implicit ec: ExecutionContext): Future[Unit]

def emptyCapped()(implicit ec: ExecutionContext): Future[Unit]

def runCommand[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R])(implicit writer: Writer[ResolvedCollectionCommand[C]], reader: Reader[R], ec: ExecutionContext): Future[R]

def runValueCommand[A <: AnyVal, R <: BoxedAnyVal[A], C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R with BoxedAnyVal[A]])(implicit writer: Writer[ResolvedCollectionCommand[C]], reader: Reader[R], ec: ExecutionContext): Future[A]

def runWithResponse[R, C <: CollectionCommand with CommandWithResult[R]](command: C with CommandWithResult[R])(implicit writer: Writer[ResolvedCollectionCommand[C]], reader: Reader[R], ec: ExecutionContext): Future[ResponseResult[R]]

def save[T](doc: T, writeConcern: WriteConcern = WriteConcern.Default)(implicit ec: ExecutionContext, writer: Writes[T]): Future[WriteResult]

Inserts the document, or updates it if it already exists in the collection.

def save(doc: Document, writeConcern: WriteConcern)(implicit ec: ExecutionContext): Future[WriteResult]

Inserts the document, or updates it if it already exists in the collection.

def save(doc: JsObject)(implicit ec: ExecutionContext): Future[WriteResult]

Inserts the document, or updates it if it already exists in the collection.

def sister[C <: Collection](name: String, failoverStrategy: FailoverStrategy)(implicit producer: CollectionProducer[C]): C

def uncheckedInsert[T](document: T)(implicit writer: Writer[T]): Unit

def uncheckedRemove[T](query: T, firstMatchOnly: Boolean)(implicit writer: Writer[T], ec: ExecutionContext): Unit

def uncheckedUpdate[S, U](selector: S, update: U, upsert: Boolean, multi: Boolean)(implicit selectorWriter: Writer[S], updateWriter: Writer[U]): Unit