IO

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def absolve[E, A](v: IO[E, Either[E, A]]): IO[E, A]

final def allowInterrupt: UIO[Unit]

final def apply[A](a: ⇒ A): Task[A]

final def asInstanceOf[T0]: T0

final def bracket[E, A, B](acquire: IO[E, A], release: (A) ⇒ UIO[Any], use: (A) ⇒ IO[E, B]): IO[E, B]

final def bracket[E, A](acquire: IO[E, A]): BracketAcquire[E, A]

final def bracketExit[E, A, B](acquire: IO[E, A], release: (A, Exit[E, B]) ⇒ UIO[Any], use: (A) ⇒ IO[E, B]): IO[E, B]

final def bracketExit[E, A](acquire: IO[E, A]): BracketExitAcquire[Any, E, A]

final def checkDaemon[E, A](f: (DaemonStatus) ⇒ IO[E, A]): IO[E, A]

final def checkInterruptible[E, A](f: (InterruptStatus) ⇒ IO[E, A]): IO[E, A]

final def checkTraced[E, A](f: (TracingStatus) ⇒ IO[E, A]): IO[E, A]

final def children: UIO[Iterable[Fiber[Any, Any]]]

def clone(): AnyRef

final def collectAll[E, A](in: Iterable[IO[E, A]]): IO[E, List[A]]

final def collectAllPar[E, A](as: Iterable[IO[E, A]]): IO[E, List[A]]

final def collectAllParN[E, A](n: Int)(as: Iterable[IO[E, A]]): IO[E, List[A]]

final def collectAllSuccesses[E, A](in: Iterable[IO[E, A]]): IO[E, List[A]]

final def collectAllSuccessesPar[E, A](as: Iterable[IO[E, A]]): IO[E, List[A]]

final def collectAllSuccessesParN[E, A](n: Int)(as: Iterable[IO[E, A]]): IO[E, List[A]]

final def collectAllWith[E, A, B](in: Iterable[IO[E, A]])(f: PartialFunction[A, B]): IO[E, List[B]]

final def collectAllWithPar[E, A, B](as: Iterable[IO[E, A]])(f: PartialFunction[A, B]): IO[E, List[B]]

final def collectAllWithParN[E, A, B](n: Int)(as: Iterable[IO[E, A]])(f: PartialFunction[A, B]): IO[E, List[B]]

final def descriptor: UIO[Descriptor]

final def descriptorWith[E, A](f: (Descriptor) ⇒ IO[E, A]): IO[E, A]

final def die(t: Throwable): UIO[Nothing]

final def dieMessage(message: String): UIO[Nothing]

final def done[E, A](r: Exit[E, A]): IO[E, A]

final def effect[A](effect: ⇒ A): Task[A]

final def effectAsync[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Unit, blockingOn: List[Id] = Nil): IO[E, A]

final def effectAsyncInterrupt[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Either[Canceler[Any], IO[E, A]], blockingOn: List[Id] = Nil): IO[E, A]

final def effectAsyncM[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ IO[E, Any]): IO[E, A]

final def effectAsyncMaybe[E, A](register: ((IO[E, A]) ⇒ Unit) ⇒ Option[IO[E, A]], blockingOn: List[Id] = Nil): IO[E, A]

final def effectSuspend[A](io: ⇒ IO[Throwable, A]): IO[Throwable, A]

final def effectSuspendTotal[E, A](io: ⇒ IO[E, A]): IO[E, A]

final def effectSuspendTotalWith[E, A](p: (Platform) ⇒ IO[E, A]): IO[E, A]

final def effectSuspendWith[A](p: (Platform) ⇒ IO[Throwable, A]): IO[Throwable, A]

final def effectTotal[A](effect: ⇒ A): UIO[A]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def fail[E](error: E): IO[E, Nothing]

final val fiberId: UIO[Id]

def finalize(): Unit

final def firstSuccessOf[E, A](io: IO[E, A], rest: Iterable[IO[E, A]]): IO[E, A]

final def flatten[E, A](io: IO[E, IO[E, A]]): IO[E, A]

final def foldLeft[E, S, A](in: Iterable[A])(zero: S)(f: (S, A) ⇒ IO[E, S]): IO[E, S]

final def foreach[E, A, B](in: Iterable[A])(f: (A) ⇒ IO[E, B]): IO[E, List[B]]

final def foreachPar[E, A, B](as: Iterable[A])(fn: (A) ⇒ IO[E, B]): IO[E, List[B]]

final def foreachParN[E, A, B](n: Int)(as: Iterable[A])(fn: (A) ⇒ IO[E, B]): IO[E, List[B]]

final def foreachParN_[E, A, B](n: Int)(as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

final def foreachPar_[E, A, B](as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

final def foreach_[E, A](as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

final def forkAll[E, A](as: Iterable[IO[E, A]]): UIO[Fiber[E, List[A]]]

final def forkAll_[E, A](as: Iterable[IO[E, A]]): UIO[Unit]

final def fromEither[E, A](v: ⇒ Either[E, A]): IO[E, A]

final def fromFiber[E, A](fiber: ⇒ Fiber[E, A]): IO[E, A]

final def fromFiberM[E, A](fiber: IO[E, Fiber[E, A]]): IO[E, A]

final def fromFunction[A](f: (Any) ⇒ A): IO[Nothing, A]

final def fromFunctionFuture[A](f: (Any) ⇒ Future[A]): Task[A]

final def fromFunctionM[E, A](f: (Any) ⇒ IO[E, A]): IO[E, A]

final def fromFuture[A](make: (ExecutionContext) ⇒ Future[A]): Task[A]

final def fromOption[A](v: ⇒ Option[A]): IO[Unit, A]

final def fromTry[A](value: ⇒ Try[A]): Task[A]

final def getClass(): Class[_]

final def halt[E](cause: Cause[E]): IO[E, Nothing]

final def haltWith[E](function: (() ⇒ ZTrace) ⇒ Cause[E]): IO[E, Nothing]

def hashCode(): Int

final def identity: IO[Nothing, Any]

final val interrupt: UIO[Nothing]

final def interruptAs(fiberId: Id): UIO[Nothing]

final def interruptible[E, A](io: IO[E, A]): IO[E, A]

final def interruptibleMask[E, A](k: (InterruptStatusRestore) ⇒ IO[E, A]): IO[E, A]

final def isInstanceOf[T0]: Boolean

final def left[E, A](a: A): IO[E, Either[A, Nothing]]

final def lock[E, A](executor: Executor)(io: IO[E, A]): IO[E, A]

final def mergeAll[E, A, B](in: Iterable[IO[E, A]])(zero: B)(f: (B, A) ⇒ B): IO[E, B]

final def mergeAllPar[E, A, B](in: Iterable[IO[E, A]])(zero: B)(f: (B, A) ⇒ B): IO[E, B]

final def ne(arg0: AnyRef): Boolean

final val never: UIO[Nothing]

final val none: UIO[Option[Nothing]]

final def notify(): Unit

final def notifyAll(): Unit

final def raceAll[E, A](io: IO[E, A], ios: Iterable[IO[E, A]]): IO[E, A]

final def reduceAll[E, A](a: IO[E, A], as: Iterable[IO[E, A]])(f: (A, A) ⇒ A): IO[E, A]

final def reduceAllPar[E, A](a: IO[E, A], as: Iterable[IO[E, A]])(f: (A, A) ⇒ A): IO[E, A]

def replicate[E, A](n: Int)(effect: IO[E, A]): Iterable[IO[E, A]]

final def require[E, A](error: E): (IO[E, Option[A]]) ⇒ IO[E, A]

final def reserve[E, A, B](reservation: IO[E, Reservation[Any, E, A]])(use: (A) ⇒ IO[E, B]): IO[E, B]

def right[E, B](b: B): IO[E, Either[Nothing, B]]

final def runtime: UIO[Runtime[Any]]

final def sequence[E, A](in: Iterable[IO[E, A]]): IO[E, List[A]]

See zio.ZIO.sequence

final def sequencePar[E, A](as: Iterable[IO[E, A]]): IO[E, List[A]]

See zio.ZIO.sequencePar

final def sequenceParN[E, A](n: Int)(as: Iterable[IO[E, A]]): IO[E, List[A]]

See zio.ZIO.sequenceParN

def some[E, A](a: A): IO[E, Option[A]]

final def succeed[A](a: A): UIO[A]

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

def toString(): String

final def trace: UIO[ZTrace]

final def traced[E, A](zio: IO[E, A]): IO[E, A]

final def traverse[E, A, B](in: Iterable[A])(f: (A) ⇒ IO[E, B]): IO[E, List[B]]

final def traversePar[E, A, B](as: Iterable[A])(fn: (A) ⇒ IO[E, B]): IO[E, List[B]]

final def traverseParN[E, A, B](n: Int)(as: Iterable[A])(fn: (A) ⇒ IO[E, B]): IO[E, List[B]]

Alias for ZIO.foreachParN

final def traverseParN_[E, A](n: Int)(as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

final def traversePar_[E, A](as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

final def traverse_[E, A](as: Iterable[A])(f: (A) ⇒ IO[E, Any]): IO[E, Unit]

final def uninterruptible[E, A](io: IO[E, A]): IO[E, A]

final def uninterruptibleMask[E, A](k: (InterruptStatusRestore) ⇒ IO[E, A]): IO[E, A]

final val unit: UIO[Unit]

final def unsandbox[E, A](v: IO[Cause[E], A]): IO[E, A]

final def untraced[E, A](zio: IO[E, A]): IO[E, A]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def when[E](b: Boolean)(io: IO[E, Any]): IO[E, Unit]

final def whenCase[R, E, A](a: A)(pf: PartialFunction[A, ZIO[R, E, Any]]): ZIO[R, E, Unit]

final def whenCaseM[R, E, A](a: ZIO[R, E, A])(pf: PartialFunction[A, ZIO[R, E, Any]]): ZIO[R, E, Unit]

final def whenM[E](b: IO[E, Boolean])(io: IO[E, Any]): IO[E, Unit]

final val yieldNow: UIO[Unit]

final def succeedLazy[A](a: ⇒ A): UIO[A]

final def suspend[E, A](io: ⇒ IO[E, A]): IO[E, A]

final def suspendWith[E, A](p: (Platform) ⇒ IO[E, A]): IO[E, A]