ZQuery

Type Members

final class Acquire[-R, +E, +A] extends AnyVal
final class AcquireExit[-R, +E, +A] extends AnyVal
final class EnvironmentWithPartiallyApplied[R] extends AnyVal
final class EnvironmentWithQueryPartiallyApplied[R] extends AnyVal
final class EnvironmentWithZIOPartiallyApplied[R] extends AnyVal
final class ProvideSomeLayer[R0, -R, +E, +A] extends AnyVal
final class Release[-R, +E, +A] extends AnyRef
final class ReleaseExit[-R, +E, E1, +A, B] extends AnyRef
final class ServiceWithPartiallyApplied[R] extends AnyVal
final class ServiceWithQueryPartiallyApplied[Service] extends AnyVal
final class ServiceWithZIOPartiallyApplied[Service] extends AnyVal
final class TimeoutTo[-R, +E, +A, +B] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def absolve[R, E, A](v: ⇒ ZQuery[R, E, Either[E, A]])(implicit trace: Trace): ZQuery[R, E, A]
def acquireReleaseExitWith[R, E, A](acquire: ⇒ ZIO[R, E, A]): AcquireExit[R, E, A]

Acquires the specified resource before the query begins execution and releases it after the query completes execution, whether by success, failure, or interruption.
def acquireReleaseWith[R, E, A](acquire: ⇒ ZIO[R, E, A]): Acquire[R, E, A]

Acquires the specified resource before the query begins execution and releases it after the query completes execution, whether by success, failure, or interruption.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@IntrinsicCandidate() @throws( ... )
def collectAll[R, E, A](as: NonEmptyChunk[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed sequentially and will be pipelined.
def collectAll[R, E, A](as: Option[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, Option[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed sequentially and will be pipelined.
def collectAll[R, E, A](as: Array[ZQuery[R, E, A]])(implicit arg0: ClassTag[A], trace: Trace): ZQuery[R, E, Array[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed sequentially and will be pipelined.
def collectAll[R, E, A](as: Set[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, Set[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed sequentially and will be pipelined.
def collectAll[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZQuery[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZQuery[R, E, A]], A, Collection[A]], trace: Trace): ZQuery[R, E, Collection[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed sequentially and will be pipelined.
def collectAllBatched[R, E, A](as: NonEmptyChunk[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[A]]

Collects a collection of queries into a query returning a collection of their results, batching requests to data sources.
def collectAllBatched[R, E, A](as: Array[ZQuery[R, E, A]])(implicit arg0: ClassTag[A], trace: Trace): ZQuery[R, E, Array[A]]

Collects a collection of queries into a query returning a collection of their results, batching requests to data sources.
def collectAllBatched[R, E, A](as: Set[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, Set[A]]

Collects a collection of queries into a query returning a collection of their results, batching requests to data sources.
def collectAllBatched[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZQuery[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZQuery[R, E, A]], A, Collection[A]], trace: Trace): ZQuery[R, E, Collection[A]]

Collects a collection of queries into a query returning a collection of their results, batching requests to data sources.
def collectAllPar[R, E, A](as: NonEmptyChunk[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
def collectAllPar[R, E, A](as: Array[ZQuery[R, E, A]])(implicit arg0: ClassTag[A], trace: Trace): ZQuery[R, E, Array[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
def collectAllPar[R, E, A](as: Set[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, Set[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
def collectAllPar[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZQuery[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZQuery[R, E, A]], A, Collection[A]], trace: Trace): ZQuery[R, E, Collection[A]]

Collects a collection of queries into a query returning a collection of their results.
Collects a collection of queries into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
def die(t: ⇒ Throwable)(implicit trace: Trace): ZQuery[Any, Nothing, Nothing]

Constructs a query that dies with the specified error.
def environment[R](implicit trace: Trace): ZQuery[R, Nothing, ZEnvironment[R]]

Accesses the whole environment of the query.
final def environmentWith[R]: EnvironmentWithPartiallyApplied[R]

Accesses the environment of the effect.
Accesses the environment of the effect.
```
val portNumber = effect.access(_.config.portNumber)
```
final def environmentWithQuery[R]: EnvironmentWithQueryPartiallyApplied[R]

Effectfully accesses the environment of the effect.
final def environmentWithZIO[R]: EnvironmentWithZIOPartiallyApplied[R]

Effectfully accesses the environment of the effect.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fail[E](error: ⇒ E)(implicit trace: Trace): ZQuery[Any, E, Nothing]

Constructs a query that fails with the specified error.
def failCause[E](cause: ⇒ Cause[E])(implicit trace: Trace): ZQuery[Any, E, Nothing]

Constructs a query that fails with the specified cause.
final def foreach[R, E, A, B](in: NonEmptyChunk[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[B]]

Applies the function f to each element of the NonEmptyChunk[A] and returns the results in a new NonEmptyChunk[B].
Applies the function f to each element of the NonEmptyChunk[A] and returns the results in a new NonEmptyChunk[B].
For a parallel version of this method, see foreachPar. If you do not need the results, see foreach_ for a more efficient implementation.
final def foreach[R, E, A, B](in: Option[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, Option[B]]

Applies the function f if the argument is non-empty and returns the results in a new Option[B].
def foreach[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ ZQuery[R, E, (Key2, Value2)])(implicit trace: Trace): ZQuery[R, E, Map[Key2, Value2]]

Applies the function f to each element of the Map[Key, Value] and returns the results in a new Map[Key2, Value2].
Applies the function f to each element of the Map[Key, Value] and returns the results in a new Map[Key2, Value2].
For a parallel version of this method, see foreachPar. If you do not need the results, see foreach_ for a more efficient implementation.
final def foreach[R, E, A, B](in: Array[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit arg0: ClassTag[B], trace: Trace): ZQuery[R, E, Array[B]]

Applies the function f to each element of the Array[A] and returns the results in a new Array[B].
Applies the function f to each element of the Array[A] and returns the results in a new Array[B].
For a parallel version of this method, see foreachPar. If you do not need the results, see foreach_ for a more efficient implementation.
final def foreach[R, E, A, B](in: Set[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, Set[B]]

Applies the function f to each element of the Set[A] and returns the results in a new Set[B].
Applies the function f to each element of the Set[A] and returns the results in a new Set[B].
For a parallel version of this method, see foreachPar. If you do not need the results, see foreach_ for a more efficient implementation.
def foreach[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: Trace): ZQuery[R, E, Collection[B]]

Performs a query for each element in a collection, collecting the results into a query returning a collection of their results.
Performs a query for each element in a collection, collecting the results into a query returning a collection of their results. Requests will be executed sequentially and will be pipelined.
final def foreachBatched[R, E, A, B](as: NonEmptyChunk[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[B]]

Performs a query for each element in a NonEmptyChunk, batching requests to data sources and collecting the results into a query returning a collection of their results.
Performs a query for each element in a NonEmptyChunk, batching requests to data sources and collecting the results into a query returning a collection of their results.
For a sequential version of this method, see foreach.
def foreachBatched[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ ZQuery[R, E, (Key2, Value2)])(implicit trace: Trace): ZQuery[R, E, Map[Key2, Value2]]

Performs a query for each element in a Map, batching requests to data sources and collecting the results into a query returning a collection of their results.
Performs a query for each element in a Map, batching requests to data sources and collecting the results into a query returning a collection of their results.
For a sequential version of this method, see foreach.
final def foreachBatched[R, E, A, B](as: Array[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit arg0: ClassTag[B], trace: Trace): ZQuery[R, E, Array[B]]

Performs a query for each element in an Array, batching requests to data sources and collecting the results into a query returning a collection of their results.
Performs a query for each element in an Array, batching requests to data sources and collecting the results into a query returning a collection of their results.
For a sequential version of this method, see foreach.
final def foreachBatched[R, E, A, B](as: Set[A])(fn: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, Set[B]]
def foreachBatched[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: Trace): ZQuery[R, E, Collection[B]]

Performs a query for each element in a collection, batching requests to data sources and collecting the results into a query returning a collection of their results.
final def foreachPar[R, E, A, B](as: NonEmptyChunk[A])(fn: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[B]]

Performs a query for each element in a NonEmptyChunk, collecting the results into a query returning a collection of their results.
Performs a query for each element in a NonEmptyChunk, collecting the results into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
For a sequential version of this method, see foreach.
def foreachPar[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ ZQuery[R, E, (Key2, Value2)])(implicit trace: Trace): ZQuery[R, E, Map[Key2, Value2]]

Performs a query for each element in a Map, collecting the results into a query returning a collection of their results.
Performs a query for each element in a Map, collecting the results into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
For a sequential version of this method, see foreach.
final def foreachPar[R, E, A, B](as: Array[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit arg0: ClassTag[B], trace: Trace): ZQuery[R, E, Array[B]]

Performs a query for each element in an Array, collecting the results into a query returning a collection of their results.
Performs a query for each element in an Array, collecting the results into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
For a sequential version of this method, see foreach.
final def foreachPar[R, E, A, B](as: Set[A])(fn: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, Set[B]]

Performs a query for each element in a Set, collecting the results into a query returning a collection of their results.
Performs a query for each element in a Set, collecting the results into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
def foreachPar[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: Trace): ZQuery[R, E, Collection[B]]

Performs a query for each element in a collection, collecting the results into a query returning a collection of their results.
Performs a query for each element in a collection, collecting the results into a query returning a collection of their results. Requests will be executed in parallel and will be batched.
def fromEither[E, A](either: ⇒ Either[E, A])(implicit trace: Trace): ZQuery[Any, E, A]

Constructs a query from an either
def fromOption[A](option: ⇒ Option[A])(implicit trace: Trace): ZQuery[Any, Option[Nothing], A]

Constructs a query from an option
def fromRequest[R, E, A, B](request0: ⇒ A)(dataSource0: ⇒ DataSource[R, A])(implicit ev: <:<[A, Request[E, B]], trace: Trace): ZQuery[R, E, B]

Constructs a query from a request and a data source.
Constructs a query from a request and a data source. Queries will die with a QueryFailure when run if the data source does not provide results for all requests received. Queries must be constructed with fromRequest or one of its variants for optimizations to be applied.
def fromRequestUncached[R, E, A, B](request: ⇒ A)(dataSource: ⇒ DataSource[R, A])(implicit ev: <:<[A, Request[E, B]], trace: Trace): ZQuery[R, E, B]

Constructs a query from a request and a data source but does not apply caching to the query.
def fromZIO[R, E, A](effect: ⇒ ZIO[R, E, A])(implicit trace: Trace): ZQuery[R, E, A]

Constructs a query from an effect.
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
Annotations
@IntrinsicCandidate()
def hashCode(): Int

Definition Classes
AnyRef → Any
Annotations
@IntrinsicCandidate()
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def never(implicit trace: Trace): ZQuery[Any, Nothing, Nothing]

Constructs a query that never completes.
val none: ZQuery[Any, Nothing, Option[Nothing]]

Constructs a query that succeds with the empty value.
final def notify(): Unit

Definition Classes
AnyRef
Annotations
@IntrinsicCandidate()
final def notifyAll(): Unit

Definition Classes
AnyRef
Annotations
@IntrinsicCandidate()
def partitionQuery[R, E, A, B](as: Iterable[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit ev: CanFail[E], trace: Trace): ZQuery[R, Nothing, (Iterable[E], Iterable[B])]

Performs a query for each element in a collection, collecting the results into a collection of failed results and a collection of successful results.
Performs a query for each element in a collection, collecting the results into a collection of failed results and a collection of successful results. Requests will be executed sequentially and will be pipelined.
def partitionQueryPar[R, E, A, B](as: Iterable[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit ev: CanFail[E], trace: Trace): ZQuery[R, Nothing, (Iterable[E], Iterable[B])]

Performs a query for each element in a collection, collecting the results into a collection of failed results and a collection of successful results.
Performs a query for each element in a collection, collecting the results into a collection of failed results and a collection of successful results. Requests will be executed in parallel and will be batched.
def service[R](implicit arg0: Tag[R], trace: Trace): ZQuery[R, Nothing, R]

Accesses the whole environment of the query.
final def serviceWith[R]: ServiceWithPartiallyApplied[R]

Accesses the environment of the effect.
Accesses the environment of the effect.
```
val portNumber = effect.access(_.config.portNumber)
```
final def serviceWithQuery[R]: ServiceWithQueryPartiallyApplied[R]

Effectfully accesses the environment of the effect.
final def serviceWithZIO[R]: ServiceWithZIOPartiallyApplied[R]

Effectfully accesses the environment of the effect.
def some[A](a: ⇒ A)(implicit trace: Trace): ZQuery[Any, Nothing, Option[A]]

Constructs a query that succeeds with the optional value.
def succeed[A](value: ⇒ A)(implicit trace: Trace): ZQuery[Any, Nothing, A]

Constructs a query that succeeds with the specified value.
def suspend[R, E, A](query: ⇒ ZQuery[R, E, A])(implicit trace: Trace): ZQuery[R, E, A]

Returns a lazily constructed query.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
val unit: ZQuery[Any, Nothing, Unit]

The query that succeeds with the unit value.
def unsandbox[R, E, A](v: ⇒ ZQuery[R, Cause[E], A])(implicit trace: Trace): ZQuery[R, E, A]

The inverse operation ZQuery.sandbox
The inverse operation ZQuery.sandbox
Terminates with exceptions on the Left side of the Either error, if it exists. Otherwise extracts the contained IO[E, A]
def unwrap[R, E, A](zio: ⇒ ZIO[R, E, ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, A]

Unwraps a query that is produced by an effect.
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Deprecated Value Members

def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@Deprecated @deprecated @throws( classOf[java.lang.Throwable] )
Deprecated
(Since version ) see corresponding Javadoc for more information.

Related Docs: class ZQuery | package query

object ZQuery

Type Members

final class Acquire[-R, +E, +A] extends AnyVal

final class AcquireExit[-R, +E, +A] extends AnyVal

final class EnvironmentWithPartiallyApplied[R] extends AnyVal

final class EnvironmentWithQueryPartiallyApplied[R] extends AnyVal

final class EnvironmentWithZIOPartiallyApplied[R] extends AnyVal

final class ProvideSomeLayer[R0, -R, +E, +A] extends AnyVal

final class Release[-R, +E, +A] extends AnyRef

final class ReleaseExit[-R, +E, E1, +A, B] extends AnyRef

final class ServiceWithPartiallyApplied[R] extends AnyVal

final class ServiceWithQueryPartiallyApplied[Service] extends AnyVal

final class ServiceWithZIOPartiallyApplied[Service] extends AnyVal

final class TimeoutTo[-R, +E, +A, +B] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def absolve[R, E, A](v: ⇒ ZQuery[R, E, Either[E, A]])(implicit trace: Trace): ZQuery[R, E, A]

def acquireReleaseExitWith[R, E, A](acquire: ⇒ ZIO[R, E, A]): AcquireExit[R, E, A]

def acquireReleaseWith[R, E, A](acquire: ⇒ ZIO[R, E, A]): Acquire[R, E, A]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collectAll[R, E, A](as: NonEmptyChunk[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[A]]

def collectAll[R, E, A](as: Option[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, Option[A]]

def collectAll[R, E, A](as: Array[ZQuery[R, E, A]])(implicit arg0: ClassTag[A], trace: Trace): ZQuery[R, E, Array[A]]

def collectAll[R, E, A](as: Set[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, Set[A]]

def collectAll[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZQuery[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZQuery[R, E, A]], A, Collection[A]], trace: Trace): ZQuery[R, E, Collection[A]]

def collectAllBatched[R, E, A](as: NonEmptyChunk[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[A]]

def collectAllBatched[R, E, A](as: Array[ZQuery[R, E, A]])(implicit arg0: ClassTag[A], trace: Trace): ZQuery[R, E, Array[A]]

def collectAllBatched[R, E, A](as: Set[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, Set[A]]

def collectAllBatched[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZQuery[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZQuery[R, E, A]], A, Collection[A]], trace: Trace): ZQuery[R, E, Collection[A]]

def collectAllPar[R, E, A](as: NonEmptyChunk[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[A]]

def collectAllPar[R, E, A](as: Array[ZQuery[R, E, A]])(implicit arg0: ClassTag[A], trace: Trace): ZQuery[R, E, Array[A]]

def collectAllPar[R, E, A](as: Set[ZQuery[R, E, A]])(implicit trace: Trace): ZQuery[R, E, Set[A]]

def collectAllPar[R, E, A, Collection[+Element] <: Iterable[Element]](as: Collection[ZQuery[R, E, A]])(implicit bf: zio.BuildFrom[Collection[ZQuery[R, E, A]], A, Collection[A]], trace: Trace): ZQuery[R, E, Collection[A]]

def die(t: ⇒ Throwable)(implicit trace: Trace): ZQuery[Any, Nothing, Nothing]

def environment[R](implicit trace: Trace): ZQuery[R, Nothing, ZEnvironment[R]]

final def environmentWith[R]: EnvironmentWithPartiallyApplied[R]

final def environmentWithQuery[R]: EnvironmentWithQueryPartiallyApplied[R]

final def environmentWithZIO[R]: EnvironmentWithZIOPartiallyApplied[R]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail[E](error: ⇒ E)(implicit trace: Trace): ZQuery[Any, E, Nothing]

def failCause[E](cause: ⇒ Cause[E])(implicit trace: Trace): ZQuery[Any, E, Nothing]

final def foreach[R, E, A, B](in: NonEmptyChunk[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[B]]

final def foreach[R, E, A, B](in: Option[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, Option[B]]

def foreach[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ ZQuery[R, E, (Key2, Value2)])(implicit trace: Trace): ZQuery[R, E, Map[Key2, Value2]]

final def foreach[R, E, A, B](in: Array[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit arg0: ClassTag[B], trace: Trace): ZQuery[R, E, Array[B]]

final def foreach[R, E, A, B](in: Set[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, Set[B]]

def foreach[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: Trace): ZQuery[R, E, Collection[B]]

final def foreachBatched[R, E, A, B](as: NonEmptyChunk[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[B]]

def foreachBatched[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ ZQuery[R, E, (Key2, Value2)])(implicit trace: Trace): ZQuery[R, E, Map[Key2, Value2]]

final def foreachBatched[R, E, A, B](as: Array[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit arg0: ClassTag[B], trace: Trace): ZQuery[R, E, Array[B]]

final def foreachBatched[R, E, A, B](as: Set[A])(fn: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, Set[B]]

def foreachBatched[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: Trace): ZQuery[R, E, Collection[B]]

final def foreachPar[R, E, A, B](as: NonEmptyChunk[A])(fn: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, NonEmptyChunk[B]]

def foreachPar[R, E, Key, Key2, Value, Value2](map: Map[Key, Value])(f: (Key, Value) ⇒ ZQuery[R, E, (Key2, Value2)])(implicit trace: Trace): ZQuery[R, E, Map[Key2, Value2]]

final def foreachPar[R, E, A, B](as: Array[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit arg0: ClassTag[B], trace: Trace): ZQuery[R, E, Array[B]]

final def foreachPar[R, E, A, B](as: Set[A])(fn: (A) ⇒ ZQuery[R, E, B])(implicit trace: Trace): ZQuery[R, E, Set[B]]

def foreachPar[R, E, A, B, Collection[+Element] <: Iterable[Element]](as: Collection[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: Trace): ZQuery[R, E, Collection[B]]

def fromEither[E, A](either: ⇒ Either[E, A])(implicit trace: Trace): ZQuery[Any, E, A]

def fromOption[A](option: ⇒ Option[A])(implicit trace: Trace): ZQuery[Any, Option[Nothing], A]

def fromRequest[R, E, A, B](request0: ⇒ A)(dataSource0: ⇒ DataSource[R, A])(implicit ev: <:<[A, Request[E, B]], trace: Trace): ZQuery[R, E, B]

def fromRequestUncached[R, E, A, B](request: ⇒ A)(dataSource: ⇒ DataSource[R, A])(implicit ev: <:<[A, Request[E, B]], trace: Trace): ZQuery[R, E, B]

def fromZIO[R, E, A](effect: ⇒ ZIO[R, E, A])(implicit trace: Trace): ZQuery[R, E, A]

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def never(implicit trace: Trace): ZQuery[Any, Nothing, Nothing]

val none: ZQuery[Any, Nothing, Option[Nothing]]

final def notify(): Unit

final def notifyAll(): Unit

def partitionQuery[R, E, A, B](as: Iterable[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit ev: CanFail[E], trace: Trace): ZQuery[R, Nothing, (Iterable[E], Iterable[B])]

def partitionQueryPar[R, E, A, B](as: Iterable[A])(f: (A) ⇒ ZQuery[R, E, B])(implicit ev: CanFail[E], trace: Trace): ZQuery[R, Nothing, (Iterable[E], Iterable[B])]

def service[R](implicit arg0: Tag[R], trace: Trace): ZQuery[R, Nothing, R]

final def serviceWith[R]: ServiceWithPartiallyApplied[R]