ZLayer

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Debug

def apply[RIn, E, ROut](zio: ZIO[RIn, E, ROut])(implicit arg0: zio.Tag[ROut], arg1: IsNotIntersection[ROut], trace: ZTraceElement): ZLayer[RIn, E, ROut]

Constructs a layer from an effectual resource.

def apply[RIn, E, ROut](managed: ZManaged[RIn, E, ROut])(implicit arg0: zio.Tag[ROut], arg1: IsNotIntersection[ROut], trace: ZTraceElement): ZLayer[RIn, E, ROut]

Constructs a layerfrom a managed resource.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def collectAll[R, E, A, Collection[+Element] <: Iterable[Element]](in: Collection[ZLayer[R, E, A]])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], ev: IsNotIntersection[Collection[A]], tag: zio.Tag[Collection[A]], bf: zio.BuildFrom[Collection[ZLayer[R, E, A]], A, Collection[A]], trace: ZTraceElement): ZLayer[R, E, Collection[A]]

Gathers up the ZLayer inside of the given collection, and combines them into a single ZLayer containing an equivalent collection of results.

final def die(t: Throwable)(implicit trace: ZTraceElement): ZLayer[Any, Nothing, Nothing]

Constructs a layer that dies with the specified throwable.

def environment[A](implicit trace: ZTraceElement): ZLayer[A, Nothing, A]

Constructs a layer that passes along the specified environment as an output.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail[E](e: E)(implicit trace: ZTraceElement): Layer[E, Nothing]

Constructs a layer that fails with the specified error.

def failCause[E](cause: Cause[E])(implicit trace: ZTraceElement): Layer[E, Nothing]

Constructs a layer that fails with the specified cause.

def finalize(): Unit

def foreach[R, E, A, B, Collection[+Element] <: Iterable[Element]](in: Collection[A])(f: (A) ⇒ ZLayer[R, E, B])(implicit arg0: zio.Tag[B], arg1: IsNotIntersection[B], ev: IsNotIntersection[Collection[B]], tag: zio.Tag[Collection[B]], bf: zio.BuildFrom[Collection[A], B, Collection[B]], trace: ZTraceElement): ZLayer[R, E, Collection[B]]

Applies the function f to each element of the Collection[A] and returns the results in a new Collection[B].

def fromAcquireRelease[R, E, A](acquire: ZIO[R, E, A])(release: (A) ⇒ URIO[R, Any])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from acquire and release actions.

def fromAcquireReleaseEnvironment[R, E, A](acquire: ZIO[R, E, ZEnvironment[A]])(release: (ZEnvironment[A]) ⇒ URIO[R, Any])(implicit trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from acquire and release actions, which must return one or more services.

def fromFunction[A, B](f: (ZEnvironment[A]) ⇒ B)(implicit arg0: zio.Tag[B], arg1: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A, Nothing, B]

Constructs a layer from the environment using the specified function.

def fromFunctionEnvironment[A, B](f: (ZEnvironment[A]) ⇒ ZEnvironment[B])(implicit trace: ZTraceElement): ZLayer[A, Nothing, B]

Constructs a layer from the environment using the specified function, which must return one or more services.

def fromFunctionEnvironmentManaged[A, E, B](f: (ZEnvironment[A]) ⇒ ZManaged[Any, E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]

Constructs a layer from the environment using the specified effectful resourceful function, which must return one or more services.

def fromFunctionEnvironmentZIO[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]

Constructs a layer from the environment using the specified effectful function, which must return one or more services.

def fromFunctionManaged[A, E, B](f: (ZEnvironment[A]) ⇒ ZManaged[Any, E, B])(implicit arg0: zio.Tag[B], arg1: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A, E, B]

Constructs a layer from the environment using the specified effectful resourceful function.

def fromFunctionZIO[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, B])(implicit arg0: zio.Tag[B], arg1: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A, E, B]

Constructs a layer from the environment using the specified effectful function.

def fromManaged[R, E, A](m: ZManaged[R, E, A])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from a managed resource.

def fromManagedEnvironment[R, E, A](m: ZManaged[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from a managed resource, which must return one or more services.

def fromZIO[R, E, A](zio: ZIO[R, E, A])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from the specified effect.

def fromZIOEnvironment[R, E, A](zio: ZIO[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from the specified effect, which must return one or more services.

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def service[A](implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ZLayer[A, Nothing, A]

Constructs a layer that accesses and returns the specified service from the environment.

def succeed[A](a: A)(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ULayer[A]

Constructs a layer from the specified value.

def succeedEnvironment[A](a: ZEnvironment[A])(implicit trace: ZTraceElement): ULayer[A]

Constructs a layer from the specified value, which must return one or more services.

def suspend[RIn, E, ROut](layer: ⇒ ZLayer[RIn, E, ROut]): ZLayer[RIn, E, ROut]

Lazily constructs a layer.

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wire[R]: WirePartiallyApplied[R]

Automatically assembles a layer for the provided type.

ZLayer.wire[Car](carLayer, wheelsLayer, engineLayer)

def wireCustom[R]: WireSomePartiallyApplied[ZEnv, R]

Automatically constructs a layer for the provided type R, leaving a remainder ZEnv.

val oldLadyLayer: ZLayer[Fly, Nothing, OldLady] = ???
val flyLayer: ZLayer[Blocking, Nothing, Fly] = ???

// The ZEnv you use later will provide both Blocking to flyLayer and Console to zio
val layer : ZLayer[ZEnv, Nothing, OldLady] = ZLayer.wireCustom[OldLady](oldLadyLayer, flyLayer)

def wireSome[R0, R]: WireSomePartiallyApplied[R0, R]

Automatically constructs a layer for the provided type R, leaving a remainder R0.

val carLayer: ZLayer[Engine with Wheels, Nothing, Car] = ???
val wheelsLayer: ZLayer[Any, Nothing, Wheels] = ???

val layer = ZLayer.wireSome[Engine, Car](carLayer, wheelsLayer)

def fromAcquireReleaseMany[R, E, A](acquire: ZIO[R, E, ZEnvironment[A]])(release: (ZEnvironment[A]) ⇒ URIO[R, Any])(implicit trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from acquire and release actions, which must return one or more services.

def fromEffect[R, E, A](zio: ZIO[R, E, A])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from the specified effect.

def fromEffectMany[R, E, A](zio: ZIO[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from the specified effect, which must return one or more services.

def fromFunctionM[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, B])(implicit arg0: zio.Tag[B], arg1: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A, E, B]

Constructs a layer from the environment using the specified effectful function.

def fromFunctionMany[A, B](f: (ZEnvironment[A]) ⇒ ZEnvironment[B])(implicit trace: ZTraceElement): ZLayer[A, Nothing, B]

Constructs a layer from the environment using the specified function, which must return one or more services.

def fromFunctionManyM[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]

Constructs a layer from the environment using the specified effectful function, which must return one or more services.

def fromFunctionManyManaged[A, E, B](f: (ZEnvironment[A]) ⇒ ZManaged[Any, E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]

Constructs a layer from the environment using the specified effectful resourceful function, which must return one or more services.

def fromFunctionManyZIO[A, E, B](f: (ZEnvironment[A]) ⇒ IO[E, ZEnvironment[B]])(implicit trace: ZTraceElement): ZLayer[A, E, B]

Constructs a layer from the environment using the specified effectful function, which must return one or more services.

def fromManagedMany[R, E, A](m: ZManaged[R, E, ZEnvironment[A]])(implicit trace: ZTraceElement): ZLayer[R, E, A]

Constructs a layer from a managed resource, which must return one or more services.

def fromService[A, B](f: (A) ⇒ B)(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], arg2: zio.Tag[B], arg3: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A, Nothing, B]

Constructs a layer that purely depends on the specified service.

def fromServiceM[A, R, E, B](f: (A) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], arg2: zio.Tag[B], arg3: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A, E, B]

Constructs a layer that effectfully depends on the specified service.

def fromServiceManaged[A, R, E, B](f: (A) ⇒ ZManaged[R, E, B])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], arg2: zio.Tag[B], arg3: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A, E, B]

Constructs a set of services that resourcefully and effectfully depends on the specified service.

def fromServiceMany[A, B](f: (A) ⇒ ZEnvironment[B])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ZLayer[A, Nothing, B]

Constructs a layer that purely depends on the specified service, which must return one or more services.

def fromServiceManyM[A, R, E, B](f: (A) ⇒ ZIO[R, E, ZEnvironment[B]])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ZLayer[R with A, E, B]

Constructs a layer that effectfully depends on the specified service, which must return one or more services.

def fromServiceManyManaged[A, R, E, B](f: (A) ⇒ ZManaged[R, E, ZEnvironment[B]])(implicit arg0: zio.Tag[A], arg1: IsNotIntersection[A], trace: ZTraceElement): ZLayer[R with A, E, B]

Constructs a layer that resourcefully and effectfully depends on the specified service, which must return one or more services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[A18], arg37: IsNotIntersection[A18], arg38: zio.Tag[A19], arg39: IsNotIntersection[A19], arg40: zio.Tag[A20], arg41: IsNotIntersection[A20], arg42: zio.Tag[A21], arg43: IsNotIntersection[A21], arg44: zio.Tag[B], arg45: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20 with A21, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[A18], arg37: IsNotIntersection[A18], arg38: zio.Tag[A19], arg39: IsNotIntersection[A19], arg40: zio.Tag[A20], arg41: IsNotIntersection[A20], arg42: zio.Tag[B], arg43: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[A18], arg37: IsNotIntersection[A18], arg38: zio.Tag[A19], arg39: IsNotIntersection[A19], arg40: zio.Tag[B], arg41: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[A18], arg37: IsNotIntersection[A18], arg38: zio.Tag[B], arg39: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[B], arg37: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[B], arg35: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[B], arg33: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[B], arg31: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[B], arg29: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[B], arg27: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[B], arg25: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[B], arg23: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[B], arg21: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, A8, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[B], arg19: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, A7, B](f: (A0, A1, A2, A3, A4, A5, A6, A7) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[B], arg17: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, A6, B](f: (A0, A1, A2, A3, A4, A5, A6) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[B], arg15: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5 with A6, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, A5, B](f: (A0, A1, A2, A3, A4, A5) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[B], arg13: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4 with A5, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, A4, B](f: (A0, A1, A2, A3, A4) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[B], arg11: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3 with A4, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, A3, B](f: (A0, A1, A2, A3) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[B], arg9: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2 with A3, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, A2, B](f: (A0, A1, A2) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[B], arg7: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1 with A2, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServices[A0, A1, B](f: (A0, A1) ⇒ B)(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[B], arg5: IsNotIntersection[B], trace: ZTraceElement): ZLayer[A0 with A1, Nothing, B]

Constructs a layer that purely depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[A18], arg37: IsNotIntersection[A18], arg38: zio.Tag[A19], arg39: IsNotIntersection[A19], arg40: zio.Tag[A20], arg41: IsNotIntersection[A20], arg42: zio.Tag[A21], arg43: IsNotIntersection[A21], arg44: zio.Tag[B], arg45: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20 with A21, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[A18], arg37: IsNotIntersection[A18], arg38: zio.Tag[A19], arg39: IsNotIntersection[A19], arg40: zio.Tag[A20], arg41: IsNotIntersection[A20], arg42: zio.Tag[B], arg43: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19 with A20, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[A18], arg37: IsNotIntersection[A18], arg38: zio.Tag[A19], arg39: IsNotIntersection[A19], arg40: zio.Tag[B], arg41: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18 with A19, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[A18], arg37: IsNotIntersection[A18], arg38: zio.Tag[B], arg39: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17 with A18, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[A17], arg35: IsNotIntersection[A17], arg36: zio.Tag[B], arg37: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16 with A17, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[A16], arg33: IsNotIntersection[A16], arg34: zio.Tag[B], arg35: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15 with A16, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[A15], arg31: IsNotIntersection[A15], arg32: zio.Tag[B], arg33: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14 with A15, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[A14], arg29: IsNotIntersection[A14], arg30: zio.Tag[B], arg31: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13 with A14, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[A13], arg27: IsNotIntersection[A13], arg28: zio.Tag[B], arg29: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12 with A13, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[A12], arg25: IsNotIntersection[A12], arg26: zio.Tag[B], arg27: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11 with A12, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[A11], arg23: IsNotIntersection[A11], arg24: zio.Tag[B], arg25: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10 with A11, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[A10], arg21: IsNotIntersection[A10], arg22: zio.Tag[B], arg23: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9 with A10, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8, A9) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[A9], arg19: IsNotIntersection[A9], arg20: zio.Tag[B], arg21: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8 with A9, E, B]

Constructs a layer that effectfully depends on the specified services.

def fromServicesM[A0, A1, A2, A3, A4, A5, A6, A7, A8, R, E, B](f: (A0, A1, A2, A3, A4, A5, A6, A7, A8) ⇒ ZIO[R, E, B])(implicit arg0: zio.Tag[A0], arg1: IsNotIntersection[A0], arg2: zio.Tag[A1], arg3: IsNotIntersection[A1], arg4: zio.Tag[A2], arg5: IsNotIntersection[A2], arg6: zio.Tag[A3], arg7: IsNotIntersection[A3], arg8: zio.Tag[A4], arg9: IsNotIntersection[A4], arg10: zio.Tag[A5], arg11: IsNotIntersection[A5], arg12: zio.Tag[A6], arg13: IsNotIntersection[A6], arg14: zio.Tag[A7], arg15: IsNotIntersection[A7], arg16: zio.Tag[A8], arg17: IsNotIntersection[A8], arg18: zio.Tag[B], arg19: IsNotIntersection[B], trace: ZTraceElement): ZLayer[R with A0 with A1 with A2 with A3 with A4 with A5 with A6 with A7 with A8, E, B]