effect 2.0.0-next.35 → 2.0.0-next.37

package/dist/declarations/src/Effect.d.ts

@@ -0,0 +1,3798 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Cause from "./Cause.js";
+import type * as Chunk from "./Chunk.js";
+import type * as Clock from "./Clock.js";
+import type { Config } from "./Config.js";
+import type { ConfigError } from "./ConfigError.js";
+import type { ConfigProvider } from "./ConfigProvider.js";
+import * as Context from "./Context.js";
+import type * as Deferred from "./Deferred.js";
+import type * as Duration from "./Duration.js";
+import type * as Either from "./Either.js";
+import type * as Equal from "./Equal.js";
+import type { Equivalence } from "./Equivalence.js";
+import type { ExecutionStrategy } from "./ExecutionStrategy.js";
+import type * as Exit from "./Exit.js";
+import type * as Fiber from "./Fiber.js";
+import type * as FiberId from "./FiberId.js";
+import type * as FiberRef from "./FiberRef.js";
+import type * as FiberRefs from "./FiberRefs.js";
+import type * as FiberRefsPatch from "./FiberRefsPatch.js";
+import type { LazyArg } from "./Function.js";
+import type * as HashMap from "./HashMap.js";
+import type * as HashSet from "./HashSet.js";
+import type { TypeLambda } from "./HKT.js";
+import type * as Layer from "./Layer.js";
+import type * as Logger from "./Logger.js";
+import type { LogLevel } from "./LogLevel.js";
+import type * as Metric from "./Metric.js";
+import type * as MetricLabel from "./MetricLabel.js";
+import type * as Option from "./Option.js";
+import type { Pipeable } from "./Pipeable.js";
+import type { Predicate, Refinement } from "./Predicate.js";
+import type * as Random from "./Random.js";
+import type * as Ref from "./Ref.js";
+import type * as Request from "./Request.js";
+import type { RequestBlock } from "./RequestBlock.js";
+import type { RequestResolver } from "./RequestResolver.js";
+import type * as Runtime from "./Runtime.js";
+import type * as RuntimeFlags from "./RuntimeFlags.js";
+import type * as RuntimeFlagsPatch from "./RuntimeFlagsPatch.js";
+import type * as Schedule from "./Schedule.js";
+import * as Scheduler from "./Scheduler.js";
+import type * as Scope from "./Scope.js";
+import type * as Supervisor from "./Supervisor.js";
+import type * as Tracer from "./Tracer.js";
+import type { Concurrency } from "./Types.js";
+import type * as Unify from "./Unify.js";
+/**
+ * @since 1.0.0
+ */
+export type MergeRecord<K, H> = {
+    [k in keyof K | keyof H]: k extends keyof K ? K[k] : k extends keyof H ? H[k] : never;
+} extends infer X ? X : never;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export declare const EffectTypeId: unique symbol;
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type EffectTypeId = typeof EffectTypeId;
+/**
+ * The `Effect` interface defines a value that lazily describes a workflow or job.
+ * The workflow requires some context `R`, and may fail with an error of type `E`,
+ * or succeed with a value of type `A`.
+ *
+ * `Effect` values model resourceful interaction with the outside world, including
+ * synchronous, asynchronous, concurrent, and parallel interaction. They use a
+ * fiber-based concurrency model, with built-in support for scheduling, fine-grained
+ * interruption, structured concurrency, and high scalability.
+ *
+ * To run an `Effect` value, you need a `Runtime`, which is a type that is capable
+ * of executing `Effect` values.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Effect<R, E, A> extends Effect.Variance<R, E, A>, Equal.Equal, Pipeable {
+    readonly [Unify.typeSymbol]?: unknown;
+    readonly [Unify.unifySymbol]?: EffectUnify<this>;
+    readonly [Unify.blacklistSymbol]?: EffectUnifyBlacklist;
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface EffectUnify<A extends {
+    [Unify.typeSymbol]?: any;
+}> extends Either.EitherUnify<A>, Option.OptionUnify<A>, Context.TagUnify<A> {
+    Effect?: () => A[Unify.typeSymbol] extends Effect<infer R0, infer E0, infer A0> | infer _ ? Effect<R0, E0, A0> : never;
+}
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface EffectUnifyBlacklist {
+    Tag?: true;
+    Option?: true;
+    Either?: true;
+}
+/**
+ * @category type lambdas
+ * @since 1.0.0
+ */
+export interface EffectTypeLambda extends TypeLambda {
+    readonly type: Effect<this["Out2"], this["Out1"], this["Target"]>;
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Blocked<R, E, A> extends Effect<R, E, A> {
+    readonly _op: "Blocked";
+    readonly i0: RequestBlock<R>;
+    readonly i1: Effect<R, E, A>;
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+declare module "./Context" {
+    interface Tag<Identifier, Service> extends Effect<Identifier, never, Service> {
+    }
+    interface TagUnifyBlacklist {
+        Effect?: true;
+        Either?: true;
+        Option?: true;
+    }
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+declare module "./Either" {
+    interface Left<E, A> extends Effect<never, E, A> {
+        readonly _tag: "Left";
+    }
+    interface Right<E, A> extends Effect<never, E, A> {
+        readonly _tag: "Right";
+    }
+    interface EitherUnifyBlacklist {
+        Effect?: true;
+        Tag?: true;
+        Option?: true;
+    }
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+declare module "./Option" {
+    interface None<A> extends Effect<never, Cause.NoSuchElementException, A> {
+        readonly _tag: "None";
+    }
+    interface Some<A> extends Effect<never, Cause.NoSuchElementException, A> {
+        readonly _tag: "Some";
+    }
+    interface OptionUnifyBlacklist {
+        Effect?: true;
+        Tag?: true;
+        Either?: true;
+    }
+}
+/**
+ * @since 1.0.0
+ */
+export declare namespace Effect {
+    /**
+     * @since 1.0.0
+     * @category models
+     */
+    interface Variance<R, E, A> {
+        readonly [EffectTypeId]: VarianceStruct<R, E, A>;
+    }
+    /**
+     * @since 1.0.0
+     * @category models
+     */
+    interface VarianceStruct<R, E, A> {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    }
+    /**
+     * @since 1.0.0
+     * @category models
+     */
+    type Unify<Ret extends Effect<any, any, any>> = Effect<Context<Ret>, Error<Ret>, Success<Ret>>;
+    /**
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Context<T extends Effect<any, any, any>> = [T] extends [Effect<infer _R, infer _E, infer _A>] ? _R : never;
+    /**
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Error<T extends Effect<any, any, any>> = [T] extends [Effect<infer _R, infer _E, infer _A>] ? _E : never;
+    /**
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Success<T extends Effect<any, any, any>> = [T] extends [Effect<infer _R, infer _E, infer _A>] ? _A : never;
+}
+/**
+ * This function returns `true` if the specified value is an `Effect` value,
+ * `false` otherwise.
+ *
+ * This function can be useful for checking the type of a value before
+ * attempting to operate on it as an `Effect` value. For example, you could
+ * use `isEffect` to check the type of a value before using it as an
+ * argument to a function that expects an `Effect` value.
+ *
+ * @param u - The value to check for being an `Effect` value.
+ *
+ * @returns `true` if the specified value is an `Effect` value, `false`
+ * otherwise.
+ *
+ * @since 1.0.0
+ * @category refinements
+ */
+export declare const isEffect: (u: unknown) => u is Effect<unknown, unknown, unknown>;
+/**
+ * Returns an effect that, if evaluated, will return the cached result of this
+ * effect. Cached results will expire after `timeToLive` duration.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+export declare const cachedWithTTL: {
+    (timeToLive: Duration.DurationInput): <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Effect<never, E, A>>;
+    <R, E, A>(self: Effect<R, E, A>, timeToLive: Duration.DurationInput): Effect<R, never, Effect<never, E, A>>;
+};
+/**
+ * Returns an effect that, if evaluated, will return the cached result of this
+ * effect. Cached results will expire after `timeToLive` duration. In
+ * addition, returns an effect that can be used to invalidate the current
+ * cached value before the `timeToLive` duration expires.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+export declare const cachedInvalidateWithTTL: {
+    (timeToLive: Duration.DurationInput): <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, [Effect<never, E, A>, Effect<never, never, void>]>;
+    <R, E, A>(self: Effect<R, E, A>, timeToLive: Duration.DurationInput): Effect<R, never, [Effect<never, E, A>, Effect<never, never, void>]>;
+};
+/**
+ * Returns an effect that, if evaluated, will return the lazily computed
+ * result of this effect.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+export declare const cached: <R, E, A>(self: Effect<R, E, A>) => Effect<never, never, Effect<R, E, A>>;
+/**
+ * Returns a memoized version of the specified effectual function.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+export declare const cachedFunction: <R, E, A, B>(f: (a: A) => Effect<R, E, B>, eq?: Equivalence<A>) => Effect<never, never, (a: A) => Effect<R, E, B>>;
+/**
+ * Returns an effect that will be executed at most once, even if it is
+ * evaluated multiple times.
+ *
+ * @since 1.0.0
+ * @category caching
+ */
+export declare const once: <R, E, A>(self: Effect<R, E, A>) => Effect<never, never, Effect<R, E, void>>;
+/**
+ * Runs all the provided effects in sequence respecting the structure provided in input.
+ *
+ * Supports multiple arguments, a single argument tuple / array or record / struct.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const all: <const Arg extends Iterable<Effect<any, any, any>> | Record<string, Effect<any, any, any>>, O extends {
+    readonly concurrency?: Concurrency;
+    readonly batching?: boolean | "inherit";
+    readonly discard?: boolean;
+    readonly mode?: "default" | "validate" | "either";
+}>(arg: Arg, options?: O) => All.Return<Arg, O>;
+/**
+ * Data-last variant of `Effect.all`.
+ *
+ * Runs all the provided effects in sequence respecting the structure provided in input.
+ *
+ * Supports multiple arguments, a single argument tuple / array or record / struct.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const allWith: <O extends {
+    readonly concurrency?: Concurrency;
+    readonly batching?: boolean | "inherit";
+    readonly discard?: boolean;
+    readonly mode?: "default" | "validate" | "either";
+}>(options?: O) => <const Arg extends Iterable<Effect<any, any, any>> | Record<string, Effect<any, any, any>>>(arg: Arg) => All.Return<Arg, O>;
+/**
+ * @since 1.0.0
+ */
+export declare namespace All {
+    /**
+     * @since 1.0.0
+     */
+    type EffectAny = Effect<any, any, any>;
+    /**
+     * @since 1.0.0
+     */
+    type ReturnIterable<T extends Iterable<EffectAny>, Discard extends boolean, Mode> = [T] extends [
+        Iterable<Effect.Variance<infer R, infer E, infer A>>
+    ] ? Effect<R, Mode extends "either" ? never : Mode extends "validate" ? Array<Option.Option<E>> : E, Discard extends true ? void : Mode extends "either" ? Array<Either.Either<E, A>> : Array<A>> : never;
+    /**
+     * @since 1.0.0
+     */
+    type ReturnTuple<T extends ReadonlyArray<unknown>, Discard extends boolean, Mode> = Effect<T[number] extends never ? never : [T[number]] extends [{
+        [EffectTypeId]: {
+            _R: (_: never) => infer R;
+        };
+    }] ? R : never, Mode extends "either" ? never : T[number] extends never ? never : Mode extends "validate" ? {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? Option.Option<_E> : never;
+    } : [T[number]] extends [{
+        [EffectTypeId]: {
+            _E: (_: never) => infer E;
+        };
+    }] ? E : never, Discard extends true ? void : T[number] extends never ? [] : Mode extends "either" ? {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? Either.Either<_E, _A> : never;
+    } : {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? _A : never;
+    }> extends infer X ? X : never;
+    /**
+     * @since 1.0.0
+     */
+    type ReturnObject<T, Discard extends boolean, Mode> = [T] extends [{
+        [K: string]: EffectAny;
+    }] ? Effect<keyof T extends never ? never : [T[keyof T]] extends [{
+        [EffectTypeId]: {
+            _R: (_: never) => infer R;
+        };
+    }] ? R : never, Mode extends "either" ? never : keyof T extends never ? never : Mode extends "validate" ? {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? Option.Option<_E> : never;
+    } : [T[keyof T]] extends [{
+        [EffectTypeId]: {
+            _E: (_: never) => infer E;
+        };
+    }] ? E : never, Discard extends true ? void : Mode extends "either" ? {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? Either.Either<_E, _A> : never;
+    } : {
+        -readonly [K in keyof T]: [T[K]] extends [Effect.Variance<infer _R, infer _E, infer _A>] ? _A : never;
+    }> : never;
+    /**
+     * @since 1.0.0
+     */
+    type IsDiscard<A> = [Extract<A, {
+        readonly discard: true;
+    }>] extends [never] ? false : true;
+    /**
+     * @since 1.0.0
+     */
+    type ExtractMode<A> = [A] extends [{
+        mode: infer M;
+    }] ? M : "default";
+    /**
+     * @since 1.0.0
+     */
+    type Return<Arg extends Iterable<EffectAny> | Record<string, EffectAny>, O extends {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard?: boolean;
+        readonly mode?: "default" | "validate" | "either";
+    }> = [Arg] extends [ReadonlyArray<EffectAny>] ? ReturnTuple<Arg, IsDiscard<O>, ExtractMode<O>> : [Arg] extends [Iterable<EffectAny>] ? ReturnIterable<Arg, IsDiscard<O>, ExtractMode<O>> : [Arg] extends [Record<string, EffectAny>] ? ReturnObject<Arg, IsDiscard<O>, ExtractMode<O>> : never;
+}
+/**
+ * Evaluate and run each effect in the structure and collect the results,
+ * discarding results from failed effects.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const allSuccesses: <R, E, A>(elements: Iterable<Effect<R, E, A>>, options?: {
+    readonly concurrency?: Concurrency;
+    readonly batching?: boolean | "inherit";
+}) => Effect<R, never, Array<A>>;
+/**
+ * Drops all elements until the effectful predicate returns true.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const dropUntil: {
+    <A, R, E>(predicate: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
+    <A, R, E>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>;
+};
+/**
+ * Drops all elements so long as the predicate returns true.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const dropWhile: {
+    <R, E, A>(f: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
+    <R, E, A>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>;
+};
+/**
+ * Determines whether all elements of the `Collection<A>` satisfies the effectual
+ * predicate `f`.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const every: {
+    <R, E, A>(f: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, boolean>;
+    <R, E, A>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, boolean>;
+};
+/**
+ * Determines whether any element of the `Iterable<A>` satisfies the effectual
+ * predicate `f`.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const exists: {
+    <R, E, A>(f: (a: A, i: number) => Effect<R, E, boolean>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): (elements: Iterable<A>) => Effect<R, E, boolean>;
+    <R, E, A>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>, options?: {
+        readonly concurrency: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R, E, boolean>;
+};
+/**
+ * Filters the collection using the specified effectful predicate.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const filter: {
+    <A, R, E>(f: (a: A, i: number) => Effect<R, E, boolean>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly negate?: boolean;
+    }): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
+    <A, R, E>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly negate?: boolean;
+    }): Effect<R, E, Array<A>>;
+};
+/**
+ * Returns the first element that satisfies the effectful predicate.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const findFirst: {
+    <A, R, E>(f: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Option.Option<A>>;
+    <A, R, E>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Option.Option<A>>;
+};
+/**
+ * This function takes an iterable of `Effect` values and returns a new
+ * `Effect` value that represents the first `Effect` value in the iterable
+ * that succeeds. If all of the `Effect` values in the iterable fail, then
+ * the resulting `Effect` value will fail as well.
+ *
+ * This function is sequential, meaning that the `Effect` values in the
+ * iterable will be executed in sequence, and the first one that succeeds
+ * will determine the outcome of the resulting `Effect` value.
+ *
+ * @param effects - The iterable of `Effect` values to evaluate.
+ *
+ * @returns A new `Effect` value that represents the first successful
+ * `Effect` value in the iterable, or a failed `Effect` value if all of the
+ * `Effect` values in the iterable fail.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const firstSuccessOf: <R, E, A>(effects: Iterable<Effect<R, E, A>>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const forEach: {
+    <A, R, E, B>(f: (a: A, i: number) => Effect<R, E, B>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard?: false;
+    }): (self: Iterable<A>) => Effect<R, E, Array<B>>;
+    <A, R, E, B>(f: (a: A, i: number) => Effect<R, E, B>, options: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard: true;
+    }): (self: Iterable<A>) => Effect<R, E, void>;
+    <A, R, E, B>(self: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard?: false;
+    }): Effect<R, E, Array<B>>;
+    <A, R, E, B>(self: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard: true;
+    }): Effect<R, E, void>;
+};
+/**
+ * Returns a successful effect with the head of the collection if the collection
+ * is non-empty, or fails with the error `None` if the collection is empty.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const head: <R, E, A>(self: Effect<R, E, Iterable<A>>) => Effect<R, Option.Option<E>, A>;
+/**
+ * Merges an `Iterable<Effect<R, E, A>>` to a single effect, working
+ * sequentially.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const mergeAll: {
+    <Z, A>(zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): <R, E>(elements: Iterable<Effect<R, E, A>>) => Effect<R, E, Z>;
+    <R, E, A, Z>(elements: Iterable<Effect<R, E, A>>, zero: Z, f: (z: Z, a: A, i: number) => Z, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R, E, Z>;
+};
+/**
+ * Feeds elements of type `A` to a function `f` that returns an effect.
+ * Collects all successes and failures in a tupled fashion.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const partition: {
+    <R, E, A, B>(f: (a: A) => Effect<R, E, B>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): (elements: Iterable<A>) => Effect<R, never, readonly [Array<E>, Array<B>]>;
+    <R, E, A, B>(elements: Iterable<A>, f: (a: A) => Effect<R, E, B>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R, never, readonly [Array<E>, Array<B>]>;
+};
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially
+ * from left to right.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const reduce: {
+    <Z, A, R, E>(zero: Z, f: (z: Z, a: A, i: number) => Effect<R, E, Z>): (elements: Iterable<A>) => Effect<R, E, Z>;
+    <Z, A, R, E>(elements: Iterable<A>, zero: Z, f: (z: Z, a: A, i: number) => Effect<R, E, Z>): Effect<R, E, Z>;
+};
+/**
+ * Reduces an `Iterable<Effect<R, E, A>>` to a single effect.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const reduceEffect: {
+    <R, E, A>(zero: Effect<R, E, A>, f: (acc: A, a: A, i: number) => A, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): (elements: Iterable<Effect<R, E, A>>) => Effect<R, E, A>;
+    <R, E, A>(elements: Iterable<Effect<R, E, A>>, zero: Effect<R, E, A>, f: (acc: A, a: A, i: number) => A, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R, E, A>;
+};
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially from left to right.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const reduceRight: {
+    <A, Z, R, E>(zero: Z, f: (a: A, z: Z, i: number) => Effect<R, E, Z>): (elements: Iterable<A>) => Effect<R, E, Z>;
+    <A, Z, R, E>(elements: Iterable<A>, zero: Z, f: (a: A, z: Z, i: number) => Effect<R, E, Z>): Effect<R, E, Z>;
+};
+/**
+ * Folds over the elements in this chunk from the left, stopping the fold early
+ * when the predicate is not satisfied.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const reduceWhile: {
+    <A, R, E, Z>(zero: Z, options: {
+        readonly while: Predicate<Z>;
+        readonly body: (s: Z, a: A, i: number) => Effect<R, E, Z>;
+    }): (elements: Iterable<A>) => Effect<R, E, Z>;
+    <A, R, E, Z>(elements: Iterable<A>, zero: Z, options: {
+        readonly while: Predicate<Z>;
+        readonly body: (s: Z, a: A, i: number) => Effect<R, E, Z>;
+    }): Effect<R, E, Z>;
+};
+/**
+ * Replicates the given effect `n` times.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const replicate: {
+    (n: number): <R, E, A>(self: Effect<R, E, A>) => Array<Effect<R, E, A>>;
+    <R, E, A>(self: Effect<R, E, A>, n: number): Array<Effect<R, E, A>>;
+};
+/**
+ * Performs this effect the specified number of times and collects the
+ * results.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const replicateEffect: {
+    (n: number, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard?: false;
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Array<A>>;
+    (n: number, options: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard: true;
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, void>;
+    <R, E, A>(self: Effect<R, E, A>, n: number, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard?: false;
+    }): Effect<R, E, Array<A>>;
+    <R, E, A>(self: Effect<R, E, A>, n: number, options: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard: true;
+    }): Effect<R, E, void>;
+};
+/**
+ * Takes elements until the effectual predicate returns true.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const takeUntil: {
+    <R, E, A>(predicate: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
+    <R, E, A>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>;
+};
+/**
+ * Takes all elements so long as the effectual predicate returns true.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const takeWhile: {
+    <R, E, A>(predicate: (a: A, i: number) => Effect<R, E, boolean>): (elements: Iterable<A>) => Effect<R, E, Array<A>>;
+    <R, E, A>(elements: Iterable<A>, predicate: (a: A, i: number) => Effect<R, E, boolean>): Effect<R, E, Array<A>>;
+};
+/**
+ * Feeds elements of type `A` to `f` and accumulates all errors in error
+ * channel or successes in success channel.
+ *
+ * This combinator is lossy meaning that if there are errors all successes
+ * will be lost. To retain all information please use `partition`.
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const validateAll: {
+    <R, E, A, B>(f: (a: A, i: number) => Effect<R, E, B>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard?: false;
+    }): (elements: Iterable<A>) => Effect<R, Array<E>, Array<B>>;
+    <R, E, A, B>(f: (a: A, i: number) => Effect<R, E, B>, options: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard: true;
+    }): (elements: Iterable<A>) => Effect<R, Array<E>, void>;
+    <R, E, A, B>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard?: false;
+    }): Effect<R, Array<E>, Array<B>>;
+    <R, E, A, B>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+        readonly discard: true;
+    }): Effect<R, Array<E>, void>;
+};
+/**
+ * Feeds elements of type `A` to `f` until it succeeds. Returns first success
+ * or the accumulation of all errors.
+ *
+ * If `elements` is empty then `Effect.fail([])` is returned.
+ *
+ * @example
+ * import * as Effect from "effect/Effect"
+ * import * as Exit from "effect/Exit"
+ *
+ * const f = (n: number) => (n > 0 ? Effect.succeed(n) : Effect.fail(`${n} is negative`))
+ *
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([], f)), Exit.fail([]))
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([1, 2], f)), Exit.succeed(1))
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([1, -1], f)), Exit.succeed(1))
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([-1, 2], f)), Exit.succeed(2))
+ * assert.deepStrictEqual(Effect.runSyncExit(Effect.validateFirst([-1, -2], f)), Exit.fail(['-1 is negative', '-2 is negative']))
+ *
+ * @since 1.0.0
+ * @category collecting & elements
+ */
+export declare const validateFirst: {
+    <R, E, A, B>(f: (a: A, i: number) => Effect<R, E, B>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): (elements: Iterable<A>) => Effect<R, Array<E>, B>;
+    <R, E, A, B>(elements: Iterable<A>, f: (a: A, i: number) => Effect<R, E, B>, options?: {
+        readonly concurrency?: Concurrency;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R, Array<E>, B>;
+};
+/**
+ * Imports an asynchronous side-effect into a pure `Effect` value.
+ * The callback function `Effect<R, E, A> => void` must be called at most once.
+ *
+ * If an Effect is returned by the registration function, it will be executed
+ * if the fiber executing the effect is interrupted.
+ *
+ * The registration function can also receive an `AbortSignal` if required for
+ * interruption.
+ *
+ * The `FiberId` of the fiber that may complete the async callback may be
+ * provided to allow for better diagnostics.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const async: <R, E, A>(register: (callback: (_: Effect<R, E, A>) => void, signal: AbortSignal) => void | Effect<R, never, void>, blockingOn?: FiberId.FiberId) => Effect<R, E, A>;
+/**
+ * Converts an asynchronous, callback-style API into an `Effect`, which will
+ * be executed asynchronously.
+ *
+ * With this variant, the registration function may return a an `Effect`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const asyncEffect: <R, E, A, R2, E2, X>(register: (callback: (_: Effect<R, E, A>) => void) => Effect<R2, E2, X>) => Effect<R | R2, E | E2, A>;
+/**
+ * Imports an asynchronous effect into a pure `Effect` value, possibly returning
+ * the value synchronously.
+ *
+ * If the register function returns a value synchronously, then the callback
+ * function `Effect<R, E, A> => void` must not be called. Otherwise the callback
+ * function must be called at most once.
+ *
+ * The `FiberId` of the fiber that may complete the async callback may be
+ * provided to allow for better diagnostics.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const asyncOption: <R, E, A>(register: (callback: (_: Effect<R, E, A>) => void) => Option.Option<Effect<R, E, A>>, blockingOn?: FiberId.FiberId) => Effect<R, E, A>;
+/**
+ * Imports an asynchronous side-effect into an effect. It has the option of
+ * returning the value synchronously, which is useful in cases where it cannot
+ * be determined if the effect is synchronous or asynchronous until the register
+ * is actually executed. It also has the option of returning a canceler,
+ * which will be used by the runtime to cancel the asynchronous effect if the fiber
+ * executing the effect is interrupted.
+ *
+ * If the register function returns a value synchronously, then the callback
+ * function `Effect<R, E, A> => void` must not be called. Otherwise the callback
+ * function must be called at most once.
+ *
+ * The `FiberId` of the fiber that may complete the async callback may be
+ * provided to allow for better diagnostics.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const asyncEither: <R, E, A>(register: (callback: (effect: Effect<R, E, A>) => void) => Either.Either<Effect<R, never, void>, Effect<R, E, A>>, blockingOn?: FiberId.FiberId) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const fail: <E>(error: E) => Effect<never, E, never>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const failSync: <E>(evaluate: LazyArg<E>) => Effect<never, E, never>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const failCause: <E>(cause: Cause.Cause<E>) => Effect<never, E, never>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const failCauseSync: <E>(evaluate: LazyArg<Cause.Cause<E>>) => Effect<never, E, never>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const die: (defect: unknown) => Effect<never, never, never>;
+/**
+ * Returns an effect that dies with a `RuntimeException` having the specified
+ * text message. This method can be used for terminating a fiber because a
+ * defect has been detected in the code.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const dieMessage: (message: string) => Effect<never, never, never>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const dieSync: (evaluate: LazyArg<unknown>) => Effect<never, never, never>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const gen: {
+    <Eff extends EffectGen<any, any, any>, AEff>(f: (resume: Adapter) => Generator<Eff, AEff, any>): Effect<[
+        Eff
+    ] extends [never] ? never : [Eff] extends [EffectGen<infer R, any, any>] ? R : never, [
+        Eff
+    ] extends [never] ? never : [Eff] extends [EffectGen<any, infer E, any>] ? E : never, AEff>;
+    <Self, Eff extends EffectGen<any, any, any>, AEff>(self: Self, f: (this: Self, resume: Adapter) => Generator<Eff, AEff, any>): Effect<[
+        Eff
+    ] extends [never] ? never : [Eff] extends [EffectGen<infer R, any, any>] ? R : never, [
+        Eff
+    ] extends [never] ? never : [Eff] extends [EffectGen<any, infer E, any>] ? E : never, AEff>;
+};
+/**
+ * @category models
+ * @since 1.0.0
+ */
+export interface EffectGen<R, E, A> {
+    readonly _R: () => R;
+    readonly _E: () => E;
+    readonly _A: () => A;
+    readonly value: Effect<R, E, A>;
+    [Symbol.iterator](): Generator<EffectGen<R, E, A>, A>;
+}
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Adapter {
+    <R, E, A>(self: Effect<R, E, A>): EffectGen<R, E, A>;
+    <A, _R, _E, _A>(a: A, ab: (a: A) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (g: H) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+    <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _R, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D, de: (d: D) => E, ef: (e: E) => F, fg: (f: F) => G, gh: (g: G) => H, hi: (h: H) => I, ij: (i: I) => J, jk: (j: J) => K, kl: (k: K) => L, lm: (l: L) => M, mn: (m: M) => N, no: (n: N) => O, op: (o: O) => P, pq: (p: P) => Q, qr: (q: Q) => R, rs: (r: R) => S, st: (s: S) => T, tu: (s: T) => Effect<_R, _E, _A>): EffectGen<_R, _E, _A>;
+}
+/**
+ * Returns a effect that will never produce anything. The moral equivalent of
+ * `while(true) {}`, only without the wasted CPU cycles.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const never: Effect<never, never, never>;
+/**
+ * Requires the option produced by this value to be `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const none: <R, E, A>(self: Effect<R, E, Option.Option<A>>) => Effect<R, Option.Option<E>, void>;
+/**
+ * Like `tryPromise` but produces a defect in case of errors.
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped Promise api.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const promise: <A>(evaluate: (signal: AbortSignal) => Promise<A>) => Effect<never, never, A>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const succeed: <A>(value: A) => Effect<never, never, A>;
+/**
+ * Returns an effect which succeeds with `None`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const succeedNone: Effect<never, never, Option.Option<never>>;
+/**
+ * Returns an effect which succeeds with the value wrapped in a `Some`.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const succeedSome: <A>(value: A) => Effect<never, never, Option.Option<A>>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const suspend: <R, E, A>(effect: LazyArg<Effect<R, E, A>>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const sync: <A>(evaluate: LazyArg<A>) => Effect<never, never, A>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const unit: Effect<never, never, void>;
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const yieldNow: (options?: {
+    readonly priority?: number;
+}) => Effect<never, never, void>;
+declare const _catch: {
+    <N extends keyof E, K extends E[N] & string, E, R1, E1, A1>(discriminator: N, options: {
+        readonly failure: K;
+        readonly onFailure: (error: Extract<E, {
+            [n in N]: K;
+        }>) => Effect<R1, E1, A1>;
+    }): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | Exclude<E, {
+        [n in N]: K;
+    }>, A1 | A>;
+    <R, E, A, N extends keyof E, K extends E[N] & string, R1, E1, A1>(self: Effect<R, E, A>, discriminator: N, options: {
+        readonly failure: K;
+        readonly onFailure: (error: Extract<E, {
+            [n in N]: K;
+        }>) => Effect<R1, E1, A1>;
+    }): Effect<R | R1, E1 | Exclude<E, {
+        [n in N]: K;
+    }>, A | A1>;
+};
+export { 
+/**
+ * Recovers from specified error.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+_catch as catch };
+/**
+ * Recovers from all recoverable errors.
+ *
+ * **Note**: that `Effect.catchAll` will not recover from unrecoverable defects. To
+ * recover from both recoverable and unrecoverable errors use
+ * `Effect.catchAllCause`.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchAll: {
+    <E, R2, E2, A2>(f: (e: E) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2, A2 | A>;
+    <R, A, E, R2, E2, A2>(self: Effect<R, E, A>, f: (e: E) => Effect<R2, E2, A2>): Effect<R | R2, E2, A | A2>;
+};
+/**
+ * Recovers from both recoverable and unrecoverable errors.
+ *
+ * See `absorb`, `sandbox`, `mapErrorCause` for other functions that can
+ * recover from defects.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchAllCause: {
+    <E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2, A2 | A>;
+    <R, A, E, R2, E2, A2>(self: Effect<R, E, A>, f: (cause: Cause.Cause<E>) => Effect<R2, E2, A2>): Effect<R | R2, E2, A | A2>;
+};
+/**
+ * Recovers from all defects with provided function.
+ *
+ * **WARNING**: There is no sensible way to recover from defects. This
+ * method should be used only at the boundary between Effect and an external
+ * system, to transmit information on a defect for diagnostic or explanatory
+ * purposes.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchAllDefect: {
+    <R2, E2, A2>(f: (defect: unknown) => Effect<R2, E2, A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, f: (defect: unknown) => Effect<R2, E2, A2>): Effect<R | R2, E | E2, A | A2>;
+};
+/**
+ * Recovers from errors that match the given predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchIf: {
+    <E, EA extends E, EB extends EA, R2, E2, A2>(refinement: Refinement<EA, EB>, f: (e: EB) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | Exclude<E, EB>, A2 | A>;
+    <E, EX extends E, R2, E2, A2>(predicate: Predicate<EX>, f: (e: EX) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A2 | A>;
+    <R, E, A, EA extends E, EB extends EA, R2, E2, A2>(self: Effect<R, E, A>, refinement: Refinement<EA, EB>, f: (e: EB) => Effect<R2, E2, A2>): Effect<R | R2, E2 | Exclude<E, EB>, A | A2>;
+    <R, E, A, EX extends E, R2, E2, A2>(self: Effect<R, E, A>, predicate: Predicate<EX>, f: (e: EX) => Effect<R2, E2, A2>): Effect<R | R2, E | E2, A | A2>;
+};
+/**
+ * Recovers from some or all of the error cases.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchSome: {
+    <E, R2, E2, A2>(pf: (e: E) => Option.Option<Effect<R2, E2, A2>>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A2 | A>;
+    <R, A, E, R2, E2, A2>(self: Effect<R, E, A>, pf: (e: E) => Option.Option<Effect<R2, E2, A2>>): Effect<R | R2, E | E2, A | A2>;
+};
+/**
+ * Recovers from some or all of the error cases with provided cause.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchSomeCause: {
+    <E, R2, E2, A2>(f: (cause: Cause.Cause<E>) => Option.Option<Effect<R2, E2, A2>>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, f: (cause: Cause.Cause<E>) => Option.Option<Effect<R2, E2, A2>>): Effect<R | R2, E | E2, A | A2>;
+};
+/**
+ * Recovers from some or all of the defects with provided partial function.
+ *
+ * **WARNING**: There is no sensible way to recover from defects. This
+ * method should be used only at the boundary between Effect and an external
+ * system, to transmit information on a defect for diagnostic or explanatory
+ * purposes.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchSomeDefect: {
+    <R2, E2, A2>(pf: (defect: unknown) => Option.Option<Effect<R2, E2, A2>>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, pf: (defect: unknown) => Option.Option<Effect<R2, E2, A2>>): Effect<R | R2, E | E2, A | A2>;
+};
+/**
+ * Recovers from the specified tagged error.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchTag: {
+    <K extends (E extends {
+        _tag: string;
+    } ? E["_tag"] : never), E, R1, E1, A1>(k: K, f: (e: Extract<E, {
+        _tag: K;
+    }>) => Effect<R1, E1, A1>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | Exclude<E, {
+        _tag: K;
+    }>, A1 | A>;
+    <R, E, A, K extends (E extends {
+        _tag: string;
+    } ? E["_tag"] : never), R1, E1, A1>(self: Effect<R, E, A>, k: K, f: (e: Extract<E, {
+        _tag: K;
+    }>) => Effect<R1, E1, A1>): Effect<R | R1, E1 | Exclude<E, {
+        _tag: K;
+    }>, A | A1>;
+};
+/**
+ * Recovers from the specified tagged errors.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const catchTags: {
+    <E, Cases extends (E extends {
+        _tag: string;
+    } ? {
+        [K in E["_tag"]]+?: ((error: Extract<E, {
+            _tag: K;
+        }>) => Effect<any, any, any>);
+    } : {})>(cases: Cases): <R, A>(self: Effect<R, E, A>) => Effect<R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer R, any, any> ? R : never;
+    }[keyof Cases], Exclude<E, {
+        _tag: keyof Cases;
+    }> | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never;
+    }[keyof Cases], A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer A> ? A : never;
+    }[keyof Cases]>;
+    <R, E, A, Cases extends (E extends {
+        _tag: string;
+    } ? {
+        [K in E["_tag"]]+?: ((error: Extract<E, {
+            _tag: K;
+        }>) => Effect<any, any, any>);
+    } : {})>(self: Effect<R, E, A>, cases: Cases): Effect<R | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<infer R, any, any> ? R : never;
+    }[keyof Cases], Exclude<E, {
+        _tag: keyof Cases;
+    }> | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, infer E, any> ? E : never;
+    }[keyof Cases], A | {
+        [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => Effect<any, any, infer A> ? A : never;
+    }[keyof Cases]>;
+};
+/**
+ * Returns an effect that succeeds with the cause of failure of this effect,
+ * or `Cause.empty` if the effect did succeed.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const cause: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Cause.Cause<E>>;
+/**
+ * Returns an effect that ignores errors and runs repeatedly until it
+ * eventually succeeds.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const eventually: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, A>;
+/**
+ * Returns a new effect that ignores the success or failure of this effect.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const ignore: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, void>;
+/**
+ * Returns a new effect that ignores the success or failure of this effect,
+ * but which also logs failures at the Debug level, just in case the failure
+ * turns out to be important.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const ignoreLogged: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, void>;
+/**
+ * Exposes all parallel errors in a single call.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const parallelErrors: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Array<E>, A>;
+/**
+ * Exposes the full `Cause` of failure for the specified effect.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const sandbox: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Cause.Cause<E>, A>;
+/**
+ * Retries with the specified retry policy. Retries are done following the
+ * failure of the original `io` (up to a fixed maximum with `once` or `recurs`
+ * for example), so that that `io.retry(Schedule.once)` means "execute `io`
+ * and in case of failure, try again once".
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const retry: {
+    <R1, E extends E0, E0, B>(policy: Schedule.Schedule<R1, E0, B>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E, A>;
+    <R, E extends E0, E0, A, R1, B>(self: Effect<R, E, A>, policy: Schedule.Schedule<R1, E0, B>): Effect<R | R1, E, A>;
+};
+/**
+ * Retries this effect the specified number of times.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const retryN: {
+    (n: number): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, n: number): Effect<R, E, A>;
+};
+/**
+ * Retries with the specified schedule, until it fails, and then both the
+ * value produced by the schedule together with the last error are passed to
+ * the recovery function.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const retryOrElse: {
+    <R1, E extends E3, A1, R2, E2, A2, E3>(policy: Schedule.Schedule<R1, E3, A1>, orElse: (e: E, out: A1) => Effect<R2, E2, A2>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R2 | R, E | E2, A2 | A>;
+    <R, E extends E3, A, R1, A1, R2, E2, A2, E3>(self: Effect<R, E, A>, policy: Schedule.Schedule<R1, E3, A1>, orElse: (e: E, out: A1) => Effect<R2, E2, A2>): Effect<R | R1 | R2, E | E2, A | A2>;
+};
+/**
+ * Retries this effect until its error satisfies the specified predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const retryUntil: {
+    <E, E2 extends E>(f: Refinement<E, E2>): <R, A>(self: Effect<R, E, A>) => Effect<R, E2, A>;
+    <E>(f: Predicate<E>): <R, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A, E2 extends E>(self: Effect<R, E, A>, f: Refinement<E, E2>): Effect<R, E2, A>;
+    <R, E, A>(self: Effect<R, E, A>, f: Predicate<E>): Effect<R, E, A>;
+};
+/**
+ * Retries this effect until its error satisfies the specified effectful
+ * predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const retryUntilEffect: {
+    <R1, E, E2>(f: (e: E) => Effect<R1, E2, boolean>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E | E2, A>;
+    <R, E, A, R1, E2>(self: Effect<R, E, A>, f: (e: E) => Effect<R1, E2, boolean>): Effect<R | R1, E | E2, A>;
+};
+/**
+ * Retries this effect while its error satisfies the specified predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const retryWhile: {
+    <E>(f: Predicate<E>): <R, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, f: Predicate<E>): Effect<R, E, A>;
+};
+/**
+ * Retries this effect while its error satisfies the specified effectful
+ * predicate.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const retryWhileEffect: {
+    <R1, E, E2>(f: (e: E) => Effect<R1, E2, boolean>): <R, A>(self: Effect<R, E, A>) => Effect<R1 | R, E | E2, A>;
+    <R, E, A, R1, E2>(self: Effect<R, E, A>, f: (e: E) => Effect<R1, E2, boolean>): Effect<R | R1, E | E2, A>;
+};
+declare const try_: {
+    <A, E>(options: {
+        readonly try: LazyArg<A>;
+        readonly catch: (error: unknown) => E;
+    }): Effect<never, E, A>;
+    <A>(evaluate: LazyArg<A>): Effect<never, unknown, A>;
+};
+export { 
+/**
+ * Imports a synchronous side-effect into a pure `Effect` value, translating any
+ * thrown exceptions into typed failed effects creating with `Effect.fail`.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+try_ as try };
+/**
+ * Returns an effect whose success is mapped by the specified side effecting
+ * `try` function, translating any promise rejections into typed failed effects
+ * via the `catch` function.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const tryMap: {
+    <A, B, E1>(options: {
+        readonly try: (a: A) => B;
+        readonly catch: (error: unknown) => E1;
+    }): <R, E>(self: Effect<R, E, A>) => Effect<R, E1 | E, B>;
+    <R, E, A, B, E1>(self: Effect<R, E, A>, options: {
+        readonly try: (a: A) => B;
+        readonly catch: (error: unknown) => E1;
+    }): Effect<R, E | E1, B>;
+};
+/**
+ * Returns an effect whose success is mapped by the specified side effecting
+ * `try` function, translating any promise rejections into typed failed effects
+ * via the `catch` function.
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped Promise api.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const tryMapPromise: {
+    <A, B, E1>(options: {
+        readonly try: (a: A, signal: AbortSignal) => Promise<B>;
+        readonly catch: (error: unknown) => E1;
+    }): <R, E>(self: Effect<R, E, A>) => Effect<R, E1 | E, B>;
+    <R, E, A, B, E1>(self: Effect<R, E, A>, options: {
+        readonly try: (a: A, signal: AbortSignal) => Promise<B>;
+        readonly catch: (error: unknown) => E1;
+    }): Effect<R, E | E1, B>;
+};
+/**
+ * Create an `Effect` that when executed will construct `promise` and wait for
+ * its result, errors will produce failure as `unknown`.
+ *
+ * An optional `AbortSignal` can be provided to allow for interruption of the
+ * wrapped Promise api.
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const tryPromise: {
+    <A, E>(options: {
+        readonly try: (signal: AbortSignal) => Promise<A>;
+        readonly catch: (error: unknown) => E;
+    }): Effect<never, E, A>;
+    <A>(try_: (signal: AbortSignal) => Promise<A>): Effect<never, unknown, A>;
+};
+/**
+ * The inverse operation `sandbox(effect)`
+ *
+ * Terminates with exceptions on the `Left` side of the `Either` error, if it
+ * exists. Otherwise extracts the contained `Effect<R, E, A>`
+ *
+ * @since 1.0.0
+ * @category error handling
+ */
+export declare const unsandbox: <R, E, A>(self: Effect<R, Cause.Cause<E>, A>) => Effect<R, E, A>;
+/**
+ * This function checks if any fibers are attempting to interrupt the current
+ * fiber, and if so, performs self-interruption.
+ *
+ * Note that this allows for interruption to occur in uninterruptible regions.
+ *
+ * @returns A new `Effect` value that represents the check for interruption
+ * and the potential self-interruption of the current fiber.
+ *
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const allowInterrupt: Effect<never, never, void>;
+/**
+ * Checks the interrupt status, and produces the effect returned by the
+ * specified callback.
+ *
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const checkInterruptible: <R, E, A>(f: (isInterruptible: boolean) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * Returns an effect whose interruption will be disconnected from the
+ * fiber's own interruption, being performed in the background without
+ * slowing down the fiber's interruption.
+ *
+ * This method is useful to create "fast interrupting" effects. For
+ * example, if you call this on a bracketed effect, then even if the
+ * effect is "stuck" in acquire or release, its interruption will return
+ * immediately, while the acquire / release are performed in the
+ * background.
+ *
+ * See timeout and race for other applications.
+ *
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const disconnect: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const interrupt: Effect<never, never, never>;
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const interruptWith: (fiberId: FiberId.FiberId) => Effect<never, never, never>;
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const interruptible: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const interruptibleMask: <R, E, A>(f: (restore: <RX, EX, AX>(effect: Effect<RX, EX, AX>) => Effect<RX, EX, AX>) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const onInterrupt: {
+    <R2, X>(cleanup: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect<R2, never, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E, A>;
+    <R, E, A, R2, X>(self: Effect<R, E, A>, cleanup: (interruptors: HashSet.HashSet<FiberId.FiberId>) => Effect<R2, never, X>): Effect<R | R2, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const uninterruptible: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category interruption
+ */
+export declare const uninterruptibleMask: <R, E, A>(f: (restore: <RX, EX, AX>(effect: Effect<RX, EX, AX>) => Effect<RX, EX, AX>) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * This function maps the success value of an `Effect` value to a specified
+ * constant value.
+ *
+ * @param value - The constant value that the success value of the `Effect`
+ * value will be mapped to.
+ * @param self - The `Effect` value whose success value will be mapped to the
+ * specified constant value.
+ *
+ * @returns A new `Effect` value that represents the mapping of the success
+ * value of the original `Effect` value to the specified constant value.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const as: {
+    <B>(value: B): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, B>;
+    <R, E, A, B>(self: Effect<R, E, A>, value: B): Effect<R, E, B>;
+};
+/**
+ * This function maps the success value of an `Effect` value to a `Some` value
+ * in an `Option` value. If the original `Effect` value fails, the returned
+ * `Effect` value will also fail.
+ *
+ * @param self - The `Effect` value whose success value will be mapped to a
+ * `Some` value in an `Option` value.
+ *
+ * @returns A new `Effect` value that represents the mapping of the success
+ * value of the original `Effect` value to a `Some` value in an `Option`
+ * value. The returned `Effect` value may fail if the original `Effect` value
+ * fails.
+ *
+ * @category mapping
+ * @since 1.0.0
+ */
+export declare const asSome: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Option.Option<A>>;
+/**
+ * This function maps the error value of an `Effect` value to a `Some` value
+ * in an `Option` value. If the original `Effect` value succeeds, the returned
+ * `Effect` value will also succeed.
+ *
+ * @param self - The `Effect` value whose error value will be mapped to a
+ * `Some` value in an `Option` value.
+ *
+ * @returns A new `Effect` value that represents the mapping of the error
+ * value of the original `Effect` value to a `Some` value in an `Option`
+ * value. The returned `Effect` value may succeed if the original `Effect`
+ * value succeeds.
+ *
+ * @category mapping
+ * @since 1.0.0
+ */
+export declare const asSomeError: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Option.Option<E>, A>;
+/**
+ * This function maps the success value of an `Effect` value to `void`. If the
+ * original `Effect` value succeeds, the returned `Effect` value will also
+ * succeed. If the original `Effect` value fails, the returned `Effect` value
+ * will fail with the same error.
+ *
+ * @param self - The `Effect` value whose success value will be mapped to `void`.
+ *
+ * @returns A new `Effect` value that represents the mapping of the success
+ * value of the original `Effect` value to `void`.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const asUnit: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, void>;
+/**
+ * Returns an effect that swaps the error/success cases. This allows you to
+ * use all methods on the error channel, possibly before flipping back.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const flip: <R, E, A>(self: Effect<R, E, A>) => Effect<R, A, E>;
+/**
+ * Swaps the error/value parameters, applies the function `f` and flips the
+ * parameters back
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const flipWith: {
+    <R, A, E, R2, A2, E2>(f: (effect: Effect<R, A, E>) => Effect<R2, A2, E2>): (self: Effect<R, E, A>) => Effect<R2, E2, A2>;
+    <R, A, E, R2, A2, E2>(self: Effect<R, E, A>, f: (effect: Effect<R, A, E>) => Effect<R2, A2, E2>): Effect<R2, E2, A2>;
+};
+/**
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const map: {
+    <A, B>(f: (a: A) => B): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>;
+    <R, E, A, B>(self: Effect<R, E, A>, f: (a: A) => B): Effect<R, E, B>;
+};
+/**
+ * Statefully and effectfully maps over the elements of this chunk to produce
+ * new elements.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapAccum: {
+    <A, B, R, E, Z>(zero: Z, f: (z: Z, a: A, i: number) => Effect<R, E, readonly [Z, B]>): (elements: Iterable<A>) => Effect<R, E, readonly [Z, Array<B>]>;
+    <A, B, R, E, Z>(elements: Iterable<A>, zero: Z, f: (z: Z, a: A, i: number) => Effect<R, E, readonly [Z, B]>): Effect<R, E, readonly [Z, Array<B>]>;
+};
+/**
+ * Returns an effect whose failure and success channels have been mapped by
+ * the specified `onFailure` and `onSuccess` functions.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapBoth: {
+    <E, A, E2, A2>(options: {
+        readonly onFailure: (e: E) => E2;
+        readonly onSuccess: (a: A) => A2;
+    }): <R>(self: Effect<R, E, A>) => Effect<R, E2, A2>;
+    <R, E, A, E2, A2>(self: Effect<R, E, A>, options: {
+        readonly onFailure: (e: E) => E2;
+        readonly onSuccess: (a: A) => A2;
+    }): Effect<R, E2, A2>;
+};
+/**
+ * Returns an effect with its error channel mapped using the specified function.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapError: {
+    <E, E2>(f: (e: E) => E2): <R, A>(self: Effect<R, E, A>) => Effect<R, E2, A>;
+    <R, A, E, E2>(self: Effect<R, E, A>, f: (e: E) => E2): Effect<R, E2, A>;
+};
+/**
+ * Returns an effect with its full cause of failure mapped using the specified
+ * function. This can be used to transform errors while preserving the
+ * original structure of `Cause`.
+ *
+ * See `absorb`, `sandbox`, `catchAllCause` for other functions for dealing
+ * with defects.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const mapErrorCause: {
+    <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <R, A>(self: Effect<R, E, A>) => Effect<R, E2, A>;
+    <R, E, A, E2>(self: Effect<R, E, A>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Effect<R, E2, A>;
+};
+/**
+ * Returns a new effect where the error channel has been merged into the
+ * success channel to their common combined type.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const merge: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, E | A>;
+/**
+ * Returns a new effect where boolean value of this effect is negated.
+ *
+ * @since 1.0.0
+ * @category mapping
+ */
+export declare const negate: <R, E>(self: Effect<R, E, boolean>) => Effect<R, E, boolean>;
+/**
+ * This function constructs a scoped resource from an `acquire` and `release`
+ * `Effect` value.
+ *
+ * If the `acquire` `Effect` value successfully completes execution, then the
+ * `release` `Effect` value will be added to the finalizers associated with the
+ * scope of this `Effect` value, and it is guaranteed to be run when the scope
+ * is closed.
+ *
+ * The `acquire` and `release` `Effect` values will be run uninterruptibly.
+ * Additionally, the `release` `Effect` value may depend on the `Exit` value
+ * specified when the scope is closed.
+ *
+ * @param acquire - The `Effect` value that acquires the resource.
+ * @param release - The `Effect` value that releases the resource.
+ *
+ * @returns A new `Effect` value that represents the scoped resource.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const acquireRelease: {
+    <A, R2, X>(release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<R2, never, X>): <R, E>(acquire: Effect<R, E, A>) => Effect<Scope.Scope | R2 | R, E, A>;
+    <R, E, A, R2, X>(acquire: Effect<R, E, A>, release: (a: A, exit: Exit.Exit<unknown, unknown>) => Effect<R2, never, X>): Effect<Scope.Scope | R | R2, E, A>;
+};
+/**
+ * This function constructs a scoped resource from an `acquire` and `release`
+ * `Effect` value.
+ *
+ * If the `acquire` `Effect` value successfully completes execution, then the
+ * `release` `Effect` value will be added to the finalizers associated with the
+ * scope of this `Effect` value, and it is guaranteed to be run when the scope
+ * is closed.
+ *
+ * The `acquire` `Effect` values will be run interruptibly.
+ * The `release` `Effect` values will be run uninterruptibly.
+ *
+ * Additionally, the `release` `Effect` value may depend on the `Exit` value
+ * specified when the scope is closed.
+ *
+ * @param acquire - The `Effect` value that acquires the resource.
+ * @param release - The `Effect` value that releases the resource.
+ *
+ * @returns A new `Effect` value that represents the scoped resource.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const acquireReleaseInterruptible: {
+    <A, R2, X>(release: (exit: Exit.Exit<unknown, unknown>) => Effect<R2, never, X>): <R, E>(acquire: Effect<R, E, A>) => Effect<Scope.Scope | R2 | R, E, A>;
+    <R, E, A, R2, X>(acquire: Effect<R, E, A>, release: (exit: Exit.Exit<unknown, unknown>) => Effect<R2, never, X>): Effect<Scope.Scope | R | R2, E, A>;
+};
+/**
+ * This function is used to ensure that an `Effect` value that represents the
+ * acquisition of a resource (for example, opening a file, launching a thread,
+ * etc.) will not be interrupted, and that the resource will always be released
+ * when the `Effect` value completes execution.
+ *
+ * `acquireUseRelease` does the following:
+ *
+ *   1. Ensures that the `Effect` value that acquires the resource will not be
+ *      interrupted. Note that acquisition may still fail due to internal
+ *      reasons (such as an uncaught exception).
+ *   2. Ensures that the `release` `Effect` value will not be interrupted,
+ *      and will be executed as long as the acquisition `Effect` value
+ *      successfully acquires the resource.
+ *
+ * During the time period between the acquisition and release of the resource,
+ * the `use` `Effect` value will be executed.
+ *
+ * If the `release` `Effect` value fails, then the entire `Effect` value will
+ * fail, even if the `use` `Effect` value succeeds. If this fail-fast behavior
+ * is not desired, errors produced by the `release` `Effect` value can be caught
+ * and ignored.
+ *
+ * @param acquire - The `Effect` value that acquires the resource.
+ * @param use - The `Effect` value that is executed between the acquisition
+ * and release of the resource.
+ * @param release - The `Effect` value that releases the resource.
+ *
+ * @returns A new `Effect` value that represents the acquisition, use, and
+ * release of the resource.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const acquireUseRelease: {
+    <A, R2, E2, A2, R3, X>(use: (a: A) => Effect<R2, E2, A2>, release: (a: A, exit: Exit.Exit<E2, A2>) => Effect<R3, never, X>): <R, E>(acquire: Effect<R, E, A>) => Effect<R2 | R3 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2, R3, X>(acquire: Effect<R, E, A>, use: (a: A) => Effect<R2, E2, A2>, release: (a: A, exit: Exit.Exit<E2, A2>) => Effect<R3, never, X>): Effect<R | R2 | R3, E | E2, A2>;
+};
+/**
+ * This function adds a finalizer to the scope of the calling `Effect` value.
+ * The finalizer is guaranteed to be run when the scope is closed, and it may
+ * depend on the `Exit` value that the scope is closed with.
+ *
+ * @param finalizer - The finalizer to add to the scope of the calling
+ * `Effect` value. This function must take an `Exit` value as its parameter,
+ * and return a new `Effect` value.
+ *
+ * @returns A new `Effect` value that represents the addition of the finalizer
+ * to the scope of the calling `Effect` value.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const addFinalizer: <R, X>(finalizer: (exit: Exit.Exit<unknown, unknown>) => Effect<R, never, X>) => Effect<R | Scope.Scope, never, void>;
+/**
+ * Returns an effect that, if this effect _starts_ execution, then the
+ * specified `finalizer` is guaranteed to be executed, whether this effect
+ * succeeds, fails, or is interrupted.
+ *
+ * For use cases that need access to the effect's result, see `onExit`.
+ *
+ * Finalizers offer very powerful guarantees, but they are low-level, and
+ * should generally not be used for releasing resources. For higher-level
+ * logic built on `ensuring`, see the `acquireRelease` family of methods.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const ensuring: {
+    <R1, X>(finalizer: Effect<R1, never, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | R, E, A>;
+    <R, E, A, R1, X>(self: Effect<R, E, A>, finalizer: Effect<R1, never, X>): Effect<R | R1, E, A>;
+};
+/**
+ * Runs the specified effect if this effect fails, providing the error to the
+ * effect if it exists. The provided effect will not be interrupted.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const onError: {
+    <E, R2, X>(cleanup: (cause: Cause.Cause<E>) => Effect<R2, never, X>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E, A>;
+    <R, A, E, R2, X>(self: Effect<R, E, A>, cleanup: (cause: Cause.Cause<E>) => Effect<R2, never, X>): Effect<R | R2, E, A>;
+};
+/**
+ * Ensures that a cleanup functions runs, whether this effect succeeds, fails,
+ * or is interrupted.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const onExit: {
+    <E, A, R2, X>(cleanup: (exit: Exit.Exit<E, A>) => Effect<R2, never, X>): <R>(self: Effect<R, E, A>) => Effect<R2 | R, E, A>;
+    <R, E, A, R2, X>(self: Effect<R, E, A>, cleanup: (exit: Exit.Exit<E, A>) => Effect<R2, never, X>): Effect<R | R2, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const parallelFinalizers: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const finalizersMask: (strategy: ExecutionStrategy) => <R, E, A>(self: (restore: <R1, E1, A1>(self: Effect<R1, E1, A1>) => Effect<R1, E1, A1>) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * Returns a new scoped workflow that runs finalizers added to the scope of
+ * this workflow sequentially in the reverse of the order in which they were
+ * added. Note that finalizers are run sequentially by default so this only
+ * has meaning if used within a scope where finalizers are being run in
+ * parallel.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const sequentialFinalizers: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const scope: Effect<Scope.Scope, never, Scope.Scope>;
+/**
+ * Accesses the current scope and uses it to perform the specified effect.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const scopeWith: <R, E, A>(f: (scope: Scope.Scope) => Effect<R, E, A>) => Effect<R | Scope.Scope, E, A>;
+/**
+ * Scopes all resources uses in this workflow to the lifetime of the workflow,
+ * ensuring that their finalizers are run as soon as this workflow completes
+ * execution, whether by success, failure, or interruption.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const scoped: <R, E, A>(effect: Effect<R, E, A>) => Effect<Exclude<R, Scope.Scope>, E, A>;
+/**
+ * Scopes all resources acquired by `resource` to the lifetime of `use`
+ * without effecting the scope of any resources acquired by `use`.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const using: {
+    <A, R2, E2, A2>(use: (a: A) => Effect<R2, E2, A2>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | Exclude<R, Scope.Scope>, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, use: (a: A) => Effect<R2, E2, A2>): Effect<R2 | Exclude<R, Scope.Scope>, E | E2, A2>;
+};
+/**
+ * Returns a new scoped workflow that returns the result of this workflow as
+ * well as a finalizer that can be run to close the scope of this workflow.
+ *
+ * @since 1.0.0
+ * @category scoping, resources & finalization
+ */
+export declare const withEarlyRelease: <R, E, A>(self: Effect<R, E, A>) => Effect<Scope.Scope | R, E, readonly [Effect<never, never, void>, A]>;
+/**
+ * Returns a new effect that will not succeed with its value before first
+ * waiting for the end of all child fibers forked by the effect.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const awaitAllChildren: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * Returns a new workflow that will not supervise any fibers forked by this
+ * workflow.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const daemonChildren: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * Constructs an effect with information about the current `Fiber`.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const descriptor: Effect<never, never, Fiber.Fiber.Descriptor>;
+/**
+ * Constructs an effect based on information about the current `Fiber`.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const descriptorWith: <R, E, A>(f: (descriptor: Fiber.Fiber.Descriptor) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * Returns a new workflow that executes this one and captures the changes in
+ * `FiberRef` values.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const diffFiberRefs: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, readonly [FiberRefsPatch.FiberRefsPatch, A]>;
+/**
+ * Acts on the children of this fiber (collected into a single fiber),
+ * guaranteeing the specified callback will be invoked, whether or not this
+ * effect succeeds.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const ensuringChild: {
+    <R2, X>(f: (fiber: Fiber.Fiber<any, ReadonlyArray<unknown>>) => Effect<R2, never, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E, A>;
+    <R, E, A, R2, X>(self: Effect<R, E, A>, f: (fiber: Fiber.Fiber<any, ReadonlyArray<unknown>>) => Effect<R2, never, X>): Effect<R | R2, E, A>;
+};
+/**
+ * Acts on the children of this fiber, guaranteeing the specified callback
+ * will be invoked, whether or not this effect succeeds.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const ensuringChildren: {
+    <R1, X>(children: (fibers: ReadonlyArray<Fiber.RuntimeFiber<any, any>>) => Effect<R1, never, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | R, E, A>;
+    <R, E, A, R1, X>(self: Effect<R, E, A>, children: (fibers: ReadonlyArray<Fiber.RuntimeFiber<any, any>>) => Effect<R1, never, X>): Effect<R | R1, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const fiberId: Effect<never, never, FiberId.FiberId>;
+/**
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const fiberIdWith: <R, E, A>(f: (descriptor: FiberId.Runtime) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * Returns an effect that forks this effect into its own separate fiber,
+ * returning the fiber immediately, without waiting for it to begin executing
+ * the effect.
+ *
+ * You can use the `fork` method whenever you want to execute an effect in a
+ * new fiber, concurrently and without "blocking" the fiber executing other
+ * effects. Using fibers can be tricky, so instead of using this method
+ * directly, consider other higher-level methods, such as `raceWith`,
+ * `zipPar`, and so forth.
+ *
+ * The fiber returned by this method has methods to interrupt the fiber and to
+ * wait for it to finish executing the effect. See `Fiber` for more
+ * information.
+ *
+ * Whenever you use this method to launch a new fiber, the new fiber is
+ * attached to the parent fiber's scope. This means when the parent fiber
+ * terminates, the child fiber will be terminated as well, ensuring that no
+ * fibers leak. This behavior is called "auto supervision", and if this
+ * behavior is not desired, you may use the `forkDaemon` or `forkIn` methods.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const fork: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+/**
+ * Forks the effect into a new fiber attached to the global scope. Because the
+ * new fiber is attached to the global scope, when the fiber executing the
+ * returned effect terminates, the forked fiber will continue running.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const forkDaemon: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+/**
+ * Returns an effect that forks all of the specified values, and returns a
+ * composite fiber that produces a list of their results, in order.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const forkAll: {
+    (options?: {
+        readonly discard?: false;
+    }): <R, E, A>(effects: Iterable<Effect<R, E, A>>) => Effect<R, never, Fiber.Fiber<E, Array<A>>>;
+    (options: {
+        readonly discard: true;
+    }): <R, E, A>(effects: Iterable<Effect<R, E, A>>) => Effect<R, never, void>;
+    <R, E, A>(effects: Iterable<Effect<R, E, A>>, options?: {
+        readonly discard?: false;
+    }): Effect<R, never, Fiber.Fiber<E, Array<A>>>;
+    <R, E, A>(effects: Iterable<Effect<R, E, A>>, options: {
+        readonly discard: true;
+    }): Effect<R, never, void>;
+};
+/**
+ * Forks the effect in the specified scope. The fiber will be interrupted
+ * when the scope is closed.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const forkIn: {
+    (scope: Scope.Scope): <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+    <R, E, A>(self: Effect<R, E, A>, scope: Scope.Scope): Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+};
+/**
+ * Forks the fiber in a `Scope`, interrupting it when the scope is closed.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const forkScoped: <R, E, A>(self: Effect<R, E, A>) => Effect<Scope.Scope | R, never, Fiber.RuntimeFiber<E, A>>;
+/**
+ * Like fork but handles an error with the provided handler.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const forkWithErrorHandler: {
+    <E, X>(handler: (e: E) => Effect<never, never, X>): <R, A>(self: Effect<R, E, A>) => Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+    <R, E, A, X>(self: Effect<R, E, A>, handler: (e: E) => Effect<never, never, X>): Effect<R, never, Fiber.RuntimeFiber<E, A>>;
+};
+/**
+ * Creates an `Effect` value that represents the exit value of the specified
+ * fiber.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const fromFiber: <E, A>(fiber: Fiber.Fiber<E, A>) => Effect<never, E, A>;
+/**
+ * Creates an `Effect` value that represents the exit value of the specified
+ * fiber.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const fromFiberEffect: <R, E, A>(fiber: Effect<R, E, Fiber.Fiber<E, A>>) => Effect<R, E, A>;
+/**
+ * Returns an effect with the behavior of this one, but where all child fibers
+ * forked in the effect are reported to the specified supervisor.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const supervised: {
+    <X>(supervisor: Supervisor.Supervisor<X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A, X>(self: Effect<R, E, A>, supervisor: Supervisor.Supervisor<X>): Effect<R, E, A>;
+};
+/**
+ * Transplants specified effects so that when those effects fork other
+ * effects, the forked effects will be governed by the scope of the fiber that
+ * executes this effect.
+ *
+ * This can be used to "graft" deep grandchildren onto a higher-level scope,
+ * effectively extending their lifespans into the parent scope.
+ *
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const transplant: <R, E, A>(f: (grafter: <R2, E2, A2>(effect: Effect<R2, E2, A2>) => Effect<R2, E2, A2>) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category supervision & fibers
+ */
+export declare const withConcurrency: {
+    (concurrency: number | "unbounded"): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, concurrency: number | "unbounded"): Effect<R, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category scheduler
+ */
+export declare const setScheduler: (scheduler: Scheduler.Scheduler) => Layer.Layer<never, never, never>;
+/**
+ * Sets the provided scheduler for usage in the wrapped effect
+ *
+ * @since 1.0.0
+ * @category scheduler
+ */
+export declare const withScheduler: {
+    (scheduler: Scheduler.Scheduler): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
+    <R, E, B>(self: Effect<R, E, B>, scheduler: Scheduler.Scheduler): Effect<R, E, B>;
+};
+/**
+ * Sets the scheduling priority used when yielding
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const withSchedulingPriority: {
+    (priority: number): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
+    <R, E, B>(self: Effect<R, E, B>, priority: number): Effect<R, E, B>;
+};
+/**
+ * Sets the maximum number of operations before yield by the default schedulers
+ *
+ * @since 1.0.0
+ * @category utils
+ */
+export declare const withMaxOpsBeforeYield: {
+    (priority: number): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
+    <R, E, B>(self: Effect<R, E, B>, priority: number): Effect<R, E, B>;
+};
+/**
+ * Retreives the `Clock` service from the context
+ *
+ * @since 1.0.0
+ * @category clock
+ */
+export declare const clock: Effect<never, never, Clock.Clock>;
+/**
+ * Retreives the `Clock` service from the context and provides it to the
+ * specified effectful function.
+ *
+ * @since 1.0.0
+ * @category clock
+ */
+export declare const clockWith: <R, E, A>(f: (clock: Clock.Clock) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category clock
+ */
+export declare const setClock: <A extends Clock.Clock>(clock: A) => Layer.Layer<never, never, never>;
+/**
+ * Sets the implementation of the clock service to the specified value and
+ * restores it to its original value when the scope is closed.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export declare const withClockScoped: <A extends Clock.Clock>(value: A) => Effect<Scope.Scope, never, void>;
+/**
+ * Executes the specified workflow with the specified implementation of the
+ * clock service.
+ *
+ * @since 1.0.0
+ * @category clock
+ */
+export declare const withClock: {
+    <A extends Clock.Clock>(value: A): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A extends Clock.Clock>(effect: Effect<R, E, A>, value: A): Effect<R, E, A>;
+};
+/**
+ * Returns an effect that is delayed from this effect by the specified
+ * `Duration`.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+export declare const delay: {
+    (duration: Duration.DurationInput): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, duration: Duration.DurationInput): Effect<R, E, A>;
+};
+/**
+ * Returns an effect that suspends for the specified duration. This method is
+ * asynchronous, and does not actually block the fiber executing the effect.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+export declare const sleep: (duration: Duration.DurationInput) => Effect<never, never, void>;
+/**
+ * Returns a new effect that executes this one and times the execution.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+export declare const timed: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, readonly [Duration.Duration, A]>;
+/**
+ * A more powerful variation of `timed` that allows specifying the clock.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+export declare const timedWith: {
+    <R1, E1>(nanoseconds: Effect<R1, E1, bigint>): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | E, readonly [Duration.Duration, A]>;
+    <R, E, A, R1, E1>(self: Effect<R, E, A>, nanoseconds: Effect<R1, E1, bigint>): Effect<R | R1, E | E1, readonly [Duration.Duration, A]>;
+};
+/**
+ * Returns an effect that will timeout this effect, returning `None` if the
+ * timeout elapses before the effect has produced a value; and returning
+ * `Some` of the produced value otherwise.
+ *
+ * If the timeout elapses without producing a value, the running effect will
+ * be safely interrupted.
+ *
+ * WARNING: The effect returned by this method will not itself return until
+ * the underlying effect is actually interrupted. This leads to more
+ * predictable resource utilization. If early return is desired, then instead
+ * of using `effect.timeout(d)`, use `effect.disconnect.timeout(d)`, which
+ * first disconnects the effect's interruption signal before performing the
+ * timeout, resulting in earliest possible return, before an underlying effect
+ * has been successfully interrupted.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+export declare const timeout: {
+    (duration: Duration.DurationInput): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Option.Option<A>>;
+    <R, E, A>(self: Effect<R, E, A>, duration: Duration.DurationInput): Effect<R, E, Option.Option<A>>;
+};
+/**
+ * The same as `timeout`, but instead of producing a `None` in the event of
+ * timeout, it will produce the specified error.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+export declare const timeoutFail: {
+    <E1>(options: {
+        readonly onTimeout: LazyArg<E1>;
+        readonly duration: Duration.DurationInput;
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E1 | E, A>;
+    <R, E, A, E1>(self: Effect<R, E, A>, options: {
+        readonly onTimeout: LazyArg<E1>;
+        readonly duration: Duration.DurationInput;
+    }): Effect<R, E | E1, A>;
+};
+/**
+ * The same as `timeout`, but instead of producing a `None` in the event of
+ * timeout, it will produce the specified failure.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+export declare const timeoutFailCause: {
+    <E1>(options: {
+        readonly onTimeout: LazyArg<Cause.Cause<E1>>;
+        readonly duration: Duration.DurationInput;
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E1 | E, A>;
+    <R, E, A, E1>(self: Effect<R, E, A>, options: {
+        readonly onTimeout: LazyArg<Cause.Cause<E1>>;
+        readonly duration: Duration.DurationInput;
+    }): Effect<R, E | E1, A>;
+};
+/**
+ * Returns an effect that will timeout this effect, returning either the
+ * default value if the timeout elapses before the effect has produced a
+ * value or returning the result of applying the function `onSuccess` to the
+ * success value of the effect.
+ *
+ * If the timeout elapses without producing a value, the running effect will
+ * be safely interrupted.
+ *
+ * @since 1.0.0
+ * @category delays & timeouts
+ */
+export declare const timeoutTo: {
+    <A, B, B1>(options: {
+        readonly onTimeout: LazyArg<B1>;
+        readonly onSuccess: (a: A) => B;
+        readonly duration: Duration.DurationInput;
+    }): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B | B1>;
+    <R, E, A, B, B1>(self: Effect<R, E, A>, options: {
+        readonly onTimeout: LazyArg<B1>;
+        readonly onSuccess: (a: A) => B;
+        readonly duration: Duration.DurationInput;
+    }): Effect<R, E, B | B1>;
+};
+/**
+ * Uses the default config provider to load the specified config, or fail with
+ * an error of type Config.Error.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+export declare const config: <A>(config: Config<A>) => Effect<never, ConfigError, A>;
+/**
+ * Retrieves the default config provider, and passes it to the specified
+ * function, which may return an effect that uses the provider to perform some
+ * work or compute some value.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+export declare const configProviderWith: <R, E, A>(f: (configProvider: ConfigProvider) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * Sets the current `ConfigProvider`.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+export declare const setConfigProvider: (configProvider: ConfigProvider) => Layer.Layer<never, never, never>;
+/**
+ * Executes the specified workflow with the specified configuration provider.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+export declare const withConfigProvider: {
+    (value: ConfigProvider): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, value: ConfigProvider): Effect<R, E, A>;
+};
+/**
+ * Sets the configuration provider to the specified value and restores it to its original value
+ * when the scope is closed.
+ *
+ * @since 1.0.0
+ * @category config
+ */
+export declare const withConfigProviderScoped: (value: ConfigProvider) => Effect<Scope.Scope, never, void>;
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const context: <R>() => Effect<R, never, Context.Context<R>>;
+/**
+ * Accesses the context of the effect.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const contextWith: <R, A>(f: (context: Context.Context<R>) => A) => Effect<R, never, A>;
+/**
+ * Effectually accesses the context of the effect.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const contextWithEffect: <R, R0, E, A>(f: (context: Context.Context<R0>) => Effect<R, E, A>) => Effect<R | R0, E, A>;
+/**
+ * Provides some of the context required to run this effect,
+ * leaving the remainder `R0`.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const mapInputContext: {
+    <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <E, A>(self: Effect<R, E, A>) => Effect<R0, E, A>;
+    <R0, R, E, A>(self: Effect<R, E, A>, f: (context: Context.Context<R0>) => Context.Context<R>): Effect<R0, E, A>;
+};
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer/context/runtime and leaving the remainder `R0`
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provide: {
+    <R2, E2, A2>(layer: Layer.Layer<R2, E2, A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | Exclude<R, A2>, E2 | E, A>;
+    <R2>(context: Context.Context<R2>): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, R2>, E, A>;
+    <R2>(runtime: Runtime.Runtime<R2>): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, R2>, E, A>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, layer: Layer.Layer<R2, E2, A2>): Effect<R2 | Exclude<R, A2>, E | E2, A>;
+    <R, E, A, R2>(self: Effect<R, E, A>, context: Context.Context<R2>): Effect<Exclude<R, R2>, E, A>;
+    <R, E, A, R2>(self: Effect<R, E, A>, runtime: Runtime.Runtime<R2>): Effect<Exclude<R, R2>, E, A>;
+};
+/**
+ * Provides the effect with the single service it requires. If the effect
+ * requires more than one service use `provideContext` instead.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provideService: {
+    <T extends Context.Tag<any, any>>(tag: T, service: Context.Tag.Service<T>): <R, E, A>(self: Effect<R, E, A>) => Effect<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
+    <R, E, A, T extends Context.Tag<any, any>>(self: Effect<R, E, A>, tag: T, service: Context.Tag.Service<T>): Effect<Exclude<R, Context.Tag.Identifier<T>>, E, A>;
+};
+/**
+ * Provides the effect with the single service it requires. If the effect
+ * requires more than one service use `provideContext` instead.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const provideServiceEffect: {
+    <T extends Context.Tag<any, any>, R1, E1>(tag: T, effect: Effect<R1, E1, Context.Tag.Service<T>>): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | Exclude<R, Context.Tag.Identifier<T>>, E1 | E, A>;
+    <R, E, A, T extends Context.Tag<any, any>, R1, E1>(self: Effect<R, E, A>, tag: T, effect: Effect<R1, E1, Context.Tag.Service<T>>): Effect<R1 | Exclude<R, Context.Tag.Identifier<T>>, E | E1, A>;
+};
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const serviceFunction: <T extends Context.Tag<any, any>, Args extends Array<any>, A>(service: T, f: (_: Context.Tag.Service<T>) => (...args: Args) => A) => (...args: Args) => Effect<Context.Tag.Identifier<T>, never, A>;
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const serviceFunctionEffect: <T extends Context.Tag<any, any>, Args extends Array<any>, R, E, A>(service: T, f: (_: Context.Tag.Service<T>) => (...args: Args) => Effect<R, E, A>) => (...args: Args) => Effect<R | Context.Tag.Identifier<T>, E, A>;
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const serviceFunctions: <I, S>(tag: Context.Tag<I, S>) => {
+    [k in {
+        [k in keyof S]: S[k] extends (...args: Array<any>) => Effect<any, any, any> ? k : never;
+    }[keyof S]]: S[k] extends (...args: infer Args) => Effect<infer R, infer E, infer A> ? (...args: Args) => Effect<R | I, E, A> : never;
+};
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const serviceConstants: <I, S>(tag: Context.Tag<I, S>) => {
+    [k in {
+        [k in keyof S]: S[k] extends Effect<any, any, any> ? k : never;
+    }[keyof S]]: S[k] extends Effect<infer R, infer E, infer A> ? Effect<R | I, E, A> : never;
+};
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const serviceMembers: <I, S>(tag: Context.Tag<I, S>) => {
+    functions: {
+        [k in {
+            [k in keyof S]: S[k] extends (...args: Array<any>) => Effect<any, any, any> ? k : never;
+        }[keyof S]]: S[k] extends (...args: infer Args) => Effect<infer R, infer E, infer A> ? (...args: Args) => Effect<R | I, E, A> : never;
+    };
+    constants: {
+        [k in {
+            [k in keyof S]: S[k] extends Effect<any, any, any> ? k : never;
+        }[keyof S]]: S[k] extends Effect<infer R, infer E, infer A> ? Effect<R | I, E, A> : never;
+    };
+};
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export declare const serviceOption: <I, A>(tag: Context.Tag<I, A>) => Effect<never, never, Option.Option<A>>;
+/**
+ * Updates the service with the required service entry.
+ *
+ * @since 1.0.0
+ * @category context
+ */
+export declare const updateService: {
+    <T extends Context.Tag<any, any>>(tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): <R, E, A>(self: Effect<R, E, A>) => Effect<R | Context.Tag.Identifier<T>, E, A>;
+    <R, E, A, T extends Context.Tag<any, any>>(self: Effect<R, E, A>, tag: T, f: (service: Context.Tag.Service<T>) => Context.Tag.Service<T>): Effect<R | Context.Tag.Identifier<T>, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category do notation
+ */
+export declare const Do: Effect<never, never, {}>;
+/**
+ * Binds an effectful value in a `do` scope
+ *
+ * @since 1.0.0
+ * @category do notation
+ */
+export declare const bind: {
+    <N extends string, K, R2, E2, A>(tag: Exclude<N, keyof K>, f: (_: K) => Effect<R2, E2, A>): <R, E>(self: Effect<R, E, K>) => Effect<R2 | R, E2 | E, MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+    <R, E, N extends string, K, R2, E2, A>(self: Effect<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => Effect<R2, E2, A>): Effect<R | R2, E | E2, MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+};
+/**
+ * @category do notation
+ * @since 1.0.0
+ */
+export declare const bindTo: {
+    <N extends string>(tag: N): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Record<N, A>>;
+    <R, E, A, N extends string>(self: Effect<R, E, A>, tag: N): Effect<R, E, Record<N, A>>;
+};
+declare const let_: {
+    <N extends string, K, A>(tag: Exclude<N, keyof K>, f: (_: K) => A): <R, E>(self: Effect<R, E, K>) => Effect<R, E, MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+    <R, E, K, N extends string, A>(self: Effect<R, E, K>, tag: Exclude<N, keyof K>, f: (_: K) => A): Effect<R, E, MergeRecord<K, {
+        [k in N]: A;
+    }>>;
+};
+export { 
+/**
+ * Like bind for values
+ *
+ * @since 1.0.0
+ * @category do notation
+ */
+let_ as let };
+/**
+ * Returns an effect whose failure and success have been lifted into an
+ * `Either`. The resulting effect cannot fail, because the failure case has
+ * been exposed as part of the `Either` success case.
+ *
+ * This method is useful for recovering from effects that may fail.
+ *
+ * The error parameter of the returned `Effect` is `never`, since it is
+ * guaranteed the effect does not model failure.
+ *
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const either: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Either.Either<E, A>>;
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const exit: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Exit.Exit<E, A>>;
+/**
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const intoDeferred: {
+    <E, A>(deferred: Deferred.Deferred<E, A>): <R>(self: Effect<R, E, A>) => Effect<R, never, boolean>;
+    <R, E, A>(self: Effect<R, E, A>, deferred: Deferred.Deferred<E, A>): Effect<R, never, boolean>;
+};
+/**
+ * Executes this effect, skipping the error but returning optionally the
+ * success.
+ *
+ * @since 1.0.0
+ * @category conversions
+ */
+export declare const option: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, Option.Option<A>>;
+declare const if_: {
+    <R1, R2, E1, E2, A, A1>(options: {
+        readonly onTrue: Effect<R1, E1, A>;
+        readonly onFalse: Effect<R2, E2, A1>;
+    }): <R = never, E = never>(self: boolean | Effect<R, E, boolean>) => Effect<R1 | R2 | R, E1 | E2 | E, A | A1>;
+    <R1, R2, E1, E2, A, A1>(self: boolean, options: {
+        readonly onTrue: Effect<R1, E1, A>;
+        readonly onFalse: Effect<R2, E2, A1>;
+    }): Effect<R1 | R2, E1 | E2, A | A1>;
+    <R, E, R1, R2, E1, E2, A, A1>(self: Effect<R, E, boolean>, options: {
+        readonly onTrue: Effect<R1, E1, A>;
+        readonly onFalse: Effect<R2, E2, A1>;
+    }): Effect<R | R1 | R2, E | E1 | E2, A | A1>;
+};
+export { 
+/**
+ * Runs `onTrue` if the result of `self` is `true` and `onFalse` otherwise.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+if_ as if };
+/**
+ * Filter the specified effect with the provided function, dying with specified
+ * defect if the predicate fails.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const filterOrDie: {
+    <A, B extends A, X extends A>(filter: Refinement<A, B>, orDieWith: (a: X) => unknown): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>;
+    <A, X extends A, Y extends A>(filter: Predicate<X>, orDieWith: (a: Y) => unknown): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A, B extends A, X extends A>(self: Effect<R, E, A>, filter: Refinement<A, B>, orDieWith: (a: X) => unknown): Effect<R, E, B>;
+    <R, E, A, X extends A, Y extends A>(self: Effect<R, E, A>, filter: Predicate<X>, orDieWith: (a: Y) => unknown): Effect<R, E, A>;
+};
+/**
+ * Filter the specified effect with the provided function, dying with specified
+ * message if the predicate fails.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const filterOrDieMessage: {
+    <A, B extends A>(filter: Refinement<A, B>, message: string): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>;
+    <A, X extends A>(filter: Predicate<X>, message: string): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A, B extends A>(self: Effect<R, E, A>, filter: Refinement<A, B>, message: string): Effect<R, E, B>;
+    <R, E, A, X extends A>(self: Effect<R, E, A>, filter: Predicate<X>, message: string): Effect<R, E, A>;
+};
+/**
+ * Filters the specified effect with the provided function returning the value
+ * of the effect if it is successful, otherwise returns the value of `orElse`.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const filterOrElse: {
+    <A, B extends A, X extends A, R2, E2, C>(filter: Refinement<A, B>, orElse: (a: X) => Effect<R2, E2, C>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, B | C>;
+    <A, X extends A, Y extends A, R2, E2, B>(filter: Predicate<X>, orElse: (a: Y) => Effect<R2, E2, B>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A | B>;
+    <R, E, A, B extends A, X extends A, R2, E2, C>(self: Effect<R, E, A>, filter: Refinement<A, B>, orElse: (a: X) => Effect<R2, E2, C>): Effect<R | R2, E | E2, B | C>;
+    <R, E, A, X extends A, Y extends A, R2, E2, B>(self: Effect<R, E, A>, filter: Predicate<X>, orElse: (a: Y) => Effect<R2, E2, B>): Effect<R | R2, E | E2, A | B>;
+};
+/**
+ * Filter the specified effect with the provided function, failing with specified
+ * error if the predicate fails.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const filterOrFail: {
+    <A, B extends A, X extends A, E2>(filter: Refinement<A, B>, orFailWith: (a: X) => E2): <R, E>(self: Effect<R, E, A>) => Effect<R, E2 | E, B>;
+    <A, X extends A, Y extends A, E2>(filter: Predicate<X>, orFailWith: (a: Y) => E2): <R, E>(self: Effect<R, E, A>) => Effect<R, E2 | E, A>;
+    <R, E, A, B extends A, X extends A, E2>(self: Effect<R, E, A>, filter: Refinement<A, B>, orFailWith: (a: X) => E2): Effect<R, E | E2, B>;
+    <R, E, A, X extends A, Y extends A, E2>(self: Effect<R, E, A>, filter: Predicate<X>, orFailWith: (a: Y) => E2): Effect<R, E | E2, A>;
+};
+/**
+ * The moral equivalent of `if (!p) exp`.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const unless: {
+    (predicate: LazyArg<boolean>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Option.Option<A>>;
+    <R, E, A>(self: Effect<R, E, A>, predicate: LazyArg<boolean>): Effect<R, E, Option.Option<A>>;
+};
+/**
+ * The moral equivalent of `if (!p) exp` when `p` has side-effects.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const unlessEffect: {
+    <R2, E2>(predicate: Effect<R2, E2, boolean>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, Option.Option<A>>;
+    <R, E, A, R2, E2>(self: Effect<R, E, A>, predicate: Effect<R2, E2, boolean>): Effect<R | R2, E | E2, Option.Option<A>>;
+};
+/**
+ * The moral equivalent of `if (p) exp`.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const when: {
+    (predicate: LazyArg<boolean>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Option.Option<A>>;
+    <R, E, A>(self: Effect<R, E, A>, predicate: LazyArg<boolean>): Effect<R, E, Option.Option<A>>;
+};
+/**
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const whenEffect: {
+    <R, E>(predicate: Effect<R, E, boolean>): <R2, E2, A>(effect: Effect<R2, E2, A>) => Effect<R | R2, E | E2, Option.Option<A>>;
+    <R, E, A, R2, E2>(self: Effect<R2, E2, A>, predicate: Effect<R, E, boolean>): Effect<R | R2, E | E2, Option.Option<A>>;
+};
+/**
+ * Executes this workflow when value of the specified `FiberRef` satisfies the
+ * predicate.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const whenFiberRef: {
+    <S>(fiberRef: FiberRef.FiberRef<S>, predicate: Predicate<S>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, readonly [S, Option.Option<A>]>;
+    <R, E, A, S>(self: Effect<R, E, A>, fiberRef: FiberRef.FiberRef<S>, predicate: Predicate<S>): Effect<R, E, readonly [S, Option.Option<A>]>;
+};
+/**
+ * Executes this workflow when the value of the `Ref` satisfies the predicate.
+ *
+ * @since 1.0.0
+ * @category filtering & conditionals
+ */
+export declare const whenRef: {
+    <S>(ref: Ref.Ref<S>, predicate: Predicate<S>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, readonly [S, Option.Option<A>]>;
+    <R, E, A, S>(self: Effect<R, E, A>, ref: Ref.Ref<S>, predicate: Predicate<S>): Effect<R, E, readonly [S, Option.Option<A>]>;
+};
+/**
+ * This function is a pipeable operator that maps over an `Effect` value,
+ * flattening the result of the mapping function into a new `Effect` value.
+ *
+ * @param f - The mapping function to apply to the `Effect` value.
+ * This function must return another `Effect` value.
+ *
+ * @returns A new `Effect` value that is the result of flattening the
+ * mapped `Effect` value.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flatMap: {
+    <A, R1, E1, B>(f: (a: A) => Effect<R1, E1, B>): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | E, B>;
+    <R, E, A, R1, E1, B>(self: Effect<R, E, A>, f: (a: A) => Effect<R1, E1, B>): Effect<R | R1, E | E1, B>;
+};
+/**
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const flatten: <R, E, R1, E1, A>(self: Effect<R, E, Effect<R1, E1, A>>) => Effect<R | R1, E | E1, A>;
+/**
+ * Returns an effect that races this effect with all the specified effects,
+ * yielding the value of the first effect to succeed with a value. Losers of
+ * the race will be interrupted immediately
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const raceAll: <R, E, A>(effects: Iterable<Effect<R, E, A>>) => Effect<R, E, A>;
+/**
+ * Returns an effect that races this effect with the specified effect,
+ * returning the first successful `A` from the faster side. If one effect
+ * succeeds, the other will be interrupted. If neither succeeds, then the
+ * effect will fail with some error.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const race: {
+    <R2, E2, A2>(that: Effect<R2, E2, A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>): Effect<R | R2, E | E2, A | A2>;
+};
+/**
+ * Returns an effect that races this effect with the specified effect,
+ * yielding the first result to complete, whether by success or failure. If
+ * neither effect completes, then the composed effect will not complete.
+ *
+ * WARNING: The raced effect will safely interrupt the "loser", but will not
+ * resume until the loser has been cleanly terminated. If early return is
+ * desired, then instead of performing `l raceFirst r`, perform
+ * `l.disconnect raceFirst r.disconnect`, which disconnects left and right
+ * interrupt signal, allowing a fast return, with interruption performed
+ * in the background.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const raceFirst: {
+    <R2, E2, A2>(that: Effect<R2, E2, A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>): Effect<R | R2, E | E2, A | A2>;
+};
+/**
+ * Returns an effect that races this effect with the specified effect, calling
+ * the specified finisher as soon as one result or the other has been computed.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const raceWith: {
+    <E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(other: Effect<R1, E1, A1>, options: {
+        readonly onSelfDone: (exit: Exit.Exit<E, A>, fiber: Fiber.Fiber<E1, A1>) => Effect<R2, E2, A2>;
+        readonly onOtherDone: (exit: Exit.Exit<E1, A1>, fiber: Fiber.Fiber<E, A>) => Effect<R3, E3, A3>;
+    }): <R>(self: Effect<R, E, A>) => Effect<R1 | R2 | R3 | R, E2 | E3, A2 | A3>;
+    <R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(self: Effect<R, E, A>, other: Effect<R1, E1, A1>, options: {
+        readonly onSelfDone: (exit: Exit.Exit<E, A>, fiber: Fiber.Fiber<E1, A1>) => Effect<R2, E2, A2>;
+        readonly onOtherDone: (exit: Exit.Exit<E1, A1>, fiber: Fiber.Fiber<E, A>) => Effect<R3, E3, A3>;
+    }): Effect<R | R1 | R2 | R3, E2 | E3, A2 | A3>;
+};
+/**
+ * Summarizes a effect by computing some value before and after execution, and
+ * then combining the values to produce a summary, together with the result of
+ * execution.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const summarized: {
+    <R2, E2, B, C>(summary: Effect<R2, E2, B>, f: (start: B, end: B) => C): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, readonly [C, A]>;
+    <R, E, A, R2, E2, B, C>(self: Effect<R, E, A>, summary: Effect<R2, E2, B>, f: (start: B, end: B) => C): Effect<R | R2, E | E2, readonly [C, A]>;
+};
+/**
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tap: {
+    <A, X extends A, R2, E2, _>(f: (a: X) => Effect<R2, E2, _>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A>;
+    <R, E, A, X extends A, R2, E2, _>(self: Effect<R, E, A>, f: (a: X) => Effect<R2, E2, _>): Effect<R | R2, E | E2, A>;
+};
+/**
+ * Returns an effect that effectfully "peeks" at the failure or success of
+ * this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tapBoth: {
+    <E, XE extends E, A, XA extends A, R2, E2, X, R3, E3, X1>(options: {
+        readonly onFailure: (e: XE) => Effect<R2, E2, X>;
+        readonly onSuccess: (a: XA) => Effect<R3, E3, X1>;
+    }): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E | E2 | E3, A>;
+    <R, E, A, XE extends E, XA extends A, R2, E2, X, R3, E3, X1>(self: Effect<R, E, A>, options: {
+        readonly onFailure: (e: XE) => Effect<R2, E2, X>;
+        readonly onSuccess: (a: XA) => Effect<R3, E3, X1>;
+    }): Effect<R | R2 | R3, E | E2 | E3, A>;
+};
+/**
+ * Returns an effect that effectually "peeks" at the defect of this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tapDefect: {
+    <R2, E2, X>(f: (cause: Cause.Cause<never>) => Effect<R2, E2, X>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, X>(self: Effect<R, E, A>, f: (cause: Cause.Cause<never>) => Effect<R2, E2, X>): Effect<R | R2, E | E2, A>;
+};
+/**
+ * Returns an effect that effectfully "peeks" at the failure of this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tapError: {
+    <E, XE extends E, R2, E2, X>(f: (e: XE) => Effect<R2, E2, X>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A>;
+    <R, E, XE extends E, A, R2, E2, X>(self: Effect<R, E, A>, f: (e: XE) => Effect<R2, E2, X>): Effect<R | R2, E | E2, A>;
+};
+/**
+ * Returns an effect that effectfully "peeks" at the specific tagged failure of this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tapErrorTag: {
+    <K extends (E extends {
+        _tag: string;
+    } ? E["_tag"] : never), E, R1, E1, A1>(k: K, f: (e: Extract<E, {
+        _tag: K;
+    }>) => Effect<R1, E1, A1>): <R, A>(self: Effect<R, E, A>) => Effect<R | R1, E | E1, A>;
+    <R, E, A, K extends (E extends {
+        _tag: string;
+    } ? E["_tag"] : never), R1, E1, A1>(self: Effect<R, E, A>, k: K, f: (e: Extract<E, {
+        _tag: K;
+    }>) => Effect<R1, E1, A1>): Effect<R | R1, E | E1, A>;
+};
+/**
+ * Returns an effect that effectually "peeks" at the cause of the failure of
+ * this effect.
+ *
+ * @since 1.0.0
+ * @category sequencing
+ */
+export declare const tapErrorCause: {
+    <E, XE extends E, R2, E2, X>(f: (cause: Cause.Cause<XE>) => Effect<R2, E2, X>): <R, A>(self: Effect<R, E, A>) => Effect<R2 | R, E | E2, A>;
+    <R, E, A, XE extends E, R2, E2, X>(self: Effect<R, E, A>, f: (cause: Cause.Cause<XE>) => Effect<R2, E2, X>): Effect<R | R2, E | E2, A>;
+};
+/**
+ * Repeats this effect forever (until the first error).
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const forever: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, never>;
+/**
+ * Iterates with the specified effectual function. The moral equivalent of:
+ *
+ * ```ts
+ * let s = initial
+ *
+ * while (cont(s)) {
+ *   s = body(s)
+ * }
+ *
+ * return s
+ * ```
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const iterate: <Z, R, E>(initial: Z, options: {
+    readonly while: (z: Z) => boolean;
+    readonly body: (z: Z) => Effect<R, E, Z>;
+}) => Effect<R, E, Z>;
+/**
+ * Loops with the specified effectual function, collecting the results into a
+ * list. The moral equivalent of:
+ *
+ * ```ts
+ * let s  = initial
+ * let as = [] as readonly A[]
+ *
+ * while (cont(s)) {
+ *   as = [body(s), ...as]
+ *   s  = inc(s)
+ * }
+ *
+ * A.reverse(as)
+ * ```
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const loop: {
+    <Z, R, E, A>(initial: Z, options: {
+        readonly while: (z: Z) => boolean;
+        readonly step: (z: Z) => Z;
+        readonly body: (z: Z) => Effect<R, E, A>;
+        readonly discard?: false;
+    }): Effect<R, E, Array<A>>;
+    <Z, R, E, A>(initial: Z, options: {
+        readonly while: (z: Z) => boolean;
+        readonly step: (z: Z) => Z;
+        readonly body: (z: Z) => Effect<R, E, A>;
+        readonly discard: true;
+    }): Effect<R, E, void>;
+};
+/**
+ * Returns a new effect that repeats this effect according to the specified
+ * schedule or until the first failure. Scheduled recurrences are in addition
+ * to the first execution, so that `io.repeat(Schedule.once)` yields an effect
+ * that executes `io`, and then if that succeeds, executes `io` an additional
+ * time.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const repeat: {
+    <R1, A extends A0, A0, B>(schedule: Schedule.Schedule<R1, A, B>): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E, B>;
+    <R, E, A extends A0, A0, R1, B>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R1, A0, B>): Effect<R | R1, E, B>;
+};
+/**
+ * Returns a new effect that repeats this effect the specified number of times
+ * or until the first failure. Repeats are in addition to the first execution,
+ * so that `io.repeatN(1)` yields an effect that executes `io`, and then if
+ * that succeeds, executes `io` an additional time.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const repeatN: {
+    (n: number): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, n: number): Effect<R, E, A>;
+};
+/**
+ * Returns a new effect that repeats this effect according to the specified
+ * schedule or until the first failure, at which point, the failure value and
+ * schedule output are passed to the specified handler.
+ *
+ * Scheduled recurrences are in addition to the first execution, so that
+ * `pipe(effect, Effect.repeat(Schedule.once()))` yields an effect that executes
+ * `effect`, and then if that succeeds, executes `effect` an additional time.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const repeatOrElse: {
+    <R2, A extends A0, A0, B, E, R3, E2>(schedule: Schedule.Schedule<R2, A, B>, orElse: (error: E, option: Option.Option<B>) => Effect<R3, E2, B>): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E2, B>;
+    <R, E, A extends A0, A0, R2, B, R3, E2>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R2, A0, B>, orElse: (error: E, option: Option.Option<B>) => Effect<R3, E2, B>): Effect<R | R2 | R3, E2, B>;
+};
+/**
+ * Repeats this effect until its value satisfies the specified predicate or
+ * until the first failure.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const repeatUntil: {
+    <A, B extends A>(f: Refinement<A, B>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, B>;
+    <A>(f: Predicate<A>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A, B extends A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, B>;
+    <R, E, A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, A>;
+};
+/**
+ * Repeats this effect until its value satisfies the specified effectful
+ * predicate or until the first failure.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const repeatUntilEffect: {
+    <A, R2, E2>(f: (a: A) => Effect<R2, E2, boolean>): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2>(self: Effect<R, E, A>, f: (a: A) => Effect<R2, E2, boolean>): Effect<R | R2, E | E2, A>;
+};
+/**
+ * Repeats this effect while its value satisfies the specified effectful
+ * predicate or until the first failure.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const repeatWhile: {
+    <A>(f: Predicate<A>): <R, E>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, f: Predicate<A>): Effect<R, E, A>;
+};
+/**
+ * Repeats this effect while its value satisfies the specified effectful
+ * predicate or until the first failure.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const repeatWhileEffect: {
+    <R1, A, E2>(f: (a: A) => Effect<R1, E2, boolean>): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E2 | E, A>;
+    <R, E, R1, A, E2>(self: Effect<R, E, A>, f: (a: A) => Effect<R1, E2, boolean>): Effect<R | R1, E | E2, A>;
+};
+/**
+ * Runs this effect according to the specified schedule.
+ *
+ * See `scheduleFrom` for a variant that allows the schedule's decision to
+ * depend on the result of this effect.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const schedule: {
+    <R2, Out>(schedule: Schedule.Schedule<R2, unknown, Out>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E, Out>;
+    <R, E, A, R2, Out>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R2, unknown, Out>): Effect<R | R2, E, Out>;
+};
+/**
+ * Runs this effect according to the specified schedule in a new fiber
+ * attached to the current scope.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const scheduleForked: {
+    <R2, Out>(schedule: Schedule.Schedule<R2, unknown, Out>): <R, E, A>(self: Effect<R, E, A>) => Effect<Scope.Scope | R2 | R, never, Fiber.RuntimeFiber<E, Out>>;
+    <R, E, A, R2, Out>(self: Effect<R, E, A>, schedule: Schedule.Schedule<R2, unknown, Out>): Effect<Scope.Scope | R | R2, never, Fiber.RuntimeFiber<E, Out>>;
+};
+/**
+ * Runs this effect according to the specified schedule starting from the
+ * specified input value.
+ *
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const scheduleFrom: {
+    <R2, In, Out>(initial: In, schedule: Schedule.Schedule<R2, In, Out>): <R, E>(self: Effect<R, E, In>) => Effect<R2 | R, E, Out>;
+    <R, E, In, R2, Out>(self: Effect<R, E, In>, initial: In, schedule: Schedule.Schedule<R2, In, Out>): Effect<R | R2, E, Out>;
+};
+/**
+ * @since 1.0.0
+ * @category repetition / recursion
+ */
+export declare const whileLoop: <R, E, A>(options: {
+    readonly while: LazyArg<boolean>;
+    readonly body: LazyArg<Effect<R, E, A>>;
+    readonly step: (a: A) => void;
+}) => Effect<R, E, void>;
+/**
+ * Returns a collection of all `FiberRef` values for the fiber running this
+ * effect.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const getFiberRefs: Effect<never, never, FiberRefs.FiberRefs>;
+/**
+ * Inherits values from all `FiberRef` instances into current fiber.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const inheritFiberRefs: (childFiberRefs: FiberRefs.FiberRefs) => Effect<never, never, void>;
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const locally: {
+    <A>(self: FiberRef.FiberRef<A>, value: A): <R, E, B>(use: Effect<R, E, B>) => Effect<R, E, B>;
+    <R, E, B, A>(use: Effect<R, E, B>, self: FiberRef.FiberRef<A>, value: A): Effect<R, E, B>;
+};
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const locallyWith: {
+    <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): <R, E, B>(use: Effect<R, E, B>) => Effect<R, E, B>;
+    <R, E, B, A>(use: Effect<R, E, B>, self: FiberRef.FiberRef<A>, f: (a: A) => A): Effect<R, E, B>;
+};
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const locallyScoped: {
+    <A>(value: A): (self: FiberRef.FiberRef<A>) => Effect<Scope.Scope, never, void>;
+    <A>(self: FiberRef.FiberRef<A>, value: A): Effect<Scope.Scope, never, void>;
+};
+/**
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const locallyScopedWith: {
+    <A>(f: (a: A) => A): (self: FiberRef.FiberRef<A>) => Effect<Scope.Scope, never, void>;
+    <A>(self: FiberRef.FiberRef<A>, f: (a: A) => A): Effect<Scope.Scope, never, void>;
+};
+/**
+ * Applies the specified changes to the `FiberRef` values for the fiber
+ * running this workflow.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const patchFiberRefs: (patch: FiberRefsPatch.FiberRefsPatch) => Effect<never, never, void>;
+/**
+ * Sets the `FiberRef` values for the fiber running this effect to the values
+ * in the specified collection of `FiberRef` values.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const setFiberRefs: (fiberRefs: FiberRefs.FiberRefs) => Effect<never, never, void>;
+/**
+ * Updates the `FiberRef` values for the fiber running this effect using the
+ * specified function.
+ *
+ * @since 1.0.0
+ * @category fiber refs
+ */
+export declare const updateFiberRefs: (f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs.FiberRefs) => FiberRefs.FiberRefs) => Effect<never, never, void>;
+/**
+ * Returns `true` if this effect is a failure, `false` otherwise.
+ *
+ * @since 1.0.0
+ * @category getters & folding
+ */
+export declare const isFailure: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, boolean>;
+/**
+ * Returns `true` if this effect is a success, `false` otherwise.
+ *
+ * @since 1.0.0
+ * @category getters & folding
+ */
+export declare const isSuccess: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, boolean>;
+/**
+ * Folds over the failure value or the success value to yield an effect that
+ * does not fail, but succeeds with the value returned by the left or right
+ * function passed to `match`.
+ *
+ * @since 1.0.0
+ * @category getters & folding
+ */
+export declare const match: {
+    <E, A, A2, A3>(options: {
+        readonly onFailure: (error: E) => A2;
+        readonly onSuccess: (value: A) => A3;
+    }): <R>(self: Effect<R, E, A>) => Effect<R, never, A2 | A3>;
+    <R, E, A, A2, A3>(self: Effect<R, E, A>, options: {
+        readonly onFailure: (error: E) => A2;
+        readonly onSuccess: (value: A) => A3;
+    }): Effect<R, never, A2 | A3>;
+};
+/**
+ * @since 1.0.0
+ * @category getters & folding
+ */
+export declare const matchCause: {
+    <E, A2, A, A3>(options: {
+        readonly onFailure: (cause: Cause.Cause<E>) => A2;
+        readonly onSuccess: (a: A) => A3;
+    }): <R>(self: Effect<R, E, A>) => Effect<R, never, A2 | A3>;
+    <R, E, A2, A, A3>(self: Effect<R, E, A>, options: {
+        readonly onFailure: (cause: Cause.Cause<E>) => A2;
+        readonly onSuccess: (a: A) => A3;
+    }): Effect<R, never, A2 | A3>;
+};
+/**
+ * @since 1.0.0
+ * @category getters & folding
+ */
+export declare const matchCauseEffect: {
+    <E, A, R2, E2, A2, R3, E3, A3>(options: {
+        readonly onFailure: (cause: Cause.Cause<E>) => Effect<R2, E2, A2>;
+        readonly onSuccess: (a: A) => Effect<R3, E3, A3>;
+    }): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E2 | E3, A2 | A3>;
+    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Effect<R, E, A>, options: {
+        readonly onFailure: (cause: Cause.Cause<E>) => Effect<R2, E2, A2>;
+        readonly onSuccess: (a: A) => Effect<R3, E3, A3>;
+    }): Effect<R | R2 | R3, E2 | E3, A2 | A3>;
+};
+/**
+ * @since 1.0.0
+ * @category getters & folding
+ */
+export declare const matchEffect: {
+    <E, A, R2, E2, A2, R3, E3, A3>(options: {
+        readonly onFailure: (e: E) => Effect<R2, E2, A2>;
+        readonly onSuccess: (a: A) => Effect<R3, E3, A3>;
+    }): <R>(self: Effect<R, E, A>) => Effect<R2 | R3 | R, E2 | E3, A2 | A3>;
+    <R, E, A, R2, E2, A2, R3, E3, A3>(self: Effect<R, E, A>, options: {
+        readonly onFailure: (e: E) => Effect<R2, E2, A2>;
+        readonly onSuccess: (a: A) => Effect<R3, E3, A3>;
+    }): Effect<R | R2 | R3, E2 | E3, A2 | A3>;
+};
+/**
+ * Logs the specified message or cause at the current log level.
+ *
+ * You can set the current log level using `FiberRef.currentLogLevel`.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const log: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+/**
+ * Logs the specified message or cause at the Trace log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const logTrace: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+/**
+ * Logs the specified message or cause at the Debug log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const logDebug: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+/**
+ * Logs the specified message or cause at the Info log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const logInfo: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+/**
+ * Logs the specified message or cause at the Warning log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const logWarning: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+/**
+ * Logs the specified message or cause at the Error log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const logError: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+/**
+ * Logs the specified message or cause at the Fatal log level.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const logFatal: <A>(messageOrCause: A, supplementary?: A extends Cause.Cause<any> ? unknown : Cause.Cause<unknown>) => Effect<never, never, void>;
+/**
+ * Adjusts the label for the current logging span.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const withLogSpan: {
+    (label: string): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, label: string): Effect<R, E, A>;
+};
+/**
+ * Annotates each log in this effect with the specified log annotation.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const annotateLogs: {
+    (key: string, value: Logger.AnnotationValue): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    (values: Record<string, Logger.AnnotationValue>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, key: string, value: Logger.AnnotationValue): Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, Logger.AnnotationValue>): Effect<R, E, A>;
+};
+/**
+ * Retrieves the log annotations associated with the current scope.
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const logAnnotations: Effect<never, never, HashMap.HashMap<string, Logger.AnnotationValue>>;
+/**
+ * Decides wether child fibers will report or not unhandled errors via the logger
+ *
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const withUnhandledErrorLogLevel: {
+    (level: Option.Option<LogLevel>): <R, E, B>(self: Effect<R, E, B>) => Effect<R, E, B>;
+    <R, E, B>(self: Effect<R, E, B>, level: Option.Option<LogLevel>): Effect<R, E, B>;
+};
+/**
+ * @since 1.0.0
+ * @category logging
+ */
+export declare const setUnhandledErrorLogLevel: (level: Option.Option<LogLevel>) => Layer.Layer<never, never, never>;
+/**
+ * Translates effect failure into death of the fiber, making all failures
+ * unchecked and not a part of the type of the effect.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+export declare const orDie: <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, A>;
+/**
+ * Keeps none of the errors, and terminates the fiber with them, using the
+ * specified function to convert the `E` into a `Throwable`.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+export declare const orDieWith: {
+    <E>(f: (error: E) => unknown): <R, A>(self: Effect<R, E, A>) => Effect<R, never, A>;
+    <R, E, A>(self: Effect<R, E, A>, f: (error: E) => unknown): Effect<R, never, A>;
+};
+/**
+ * Executes this effect and returns its value, if it succeeds, but otherwise
+ * executes the specified effect.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+export declare const orElse: {
+    <R2, E2, A2>(that: LazyArg<Effect<R2, E2, A2>>): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2, A2 | A>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: LazyArg<Effect<R2, E2, A2>>): Effect<R | R2, E2, A | A2>;
+};
+/**
+ * Executes this effect and returns its value, if it succeeds, but otherwise
+ * fails with the specified error.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+export declare const orElseFail: {
+    <E2>(evaluate: LazyArg<E2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E2, A>;
+    <R, E, A, E2>(self: Effect<R, E, A>, evaluate: LazyArg<E2>): Effect<R, E2, A>;
+};
+/**
+ * Executes this effect and returns its value, if it succeeds, but
+ * otherwise succeeds with the specified value.
+ *
+ * @since 1.0.0
+ * @category alternatives
+ */
+export declare const orElseSucceed: {
+    <A2>(evaluate: LazyArg<A2>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, never, A2 | A>;
+    <R, E, A, A2>(self: Effect<R, E, A>, evaluate: LazyArg<A2>): Effect<R, never, A | A2>;
+};
+/**
+ * Retreives the `Random` service from the context.
+ *
+ * @since 1.0.0
+ * @category random
+ */
+export declare const random: Effect<never, never, Random.Random>;
+/**
+ * Retreives the `Random` service from the context and uses it to run the
+ * specified workflow.
+ *
+ * @since 1.0.0
+ * @category random
+ */
+export declare const randomWith: <R, E, A>(f: (random: Random.Random) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * Returns an effect that accesses the runtime, which can be used to
+ * (unsafely) execute tasks. This is useful for integration with legacy code
+ * that must call back into Effect code.
+ *
+ * @since 1.0.0
+ * @category runtime
+ */
+export declare const runtime: <R>() => Effect<R, never, Runtime.Runtime<R>>;
+/**
+ * Retrieves an effect that succeeds with the current runtime flags, which
+ * govern behavior and features of the runtime system.
+ *
+ * @since 1.0.0
+ * @category runtime
+ */
+export declare const getRuntimeFlags: Effect<never, never, RuntimeFlags.RuntimeFlags>;
+/**
+ * @since 1.0.0
+ * @category runtime
+ */
+export declare const patchRuntimeFlags: (patch: RuntimeFlagsPatch.RuntimeFlagsPatch) => Effect<never, never, void>;
+/**
+ * @since 1.0.0
+ * @category runtime
+ */
+export declare const withRuntimeFlagsPatch: {
+    (update: RuntimeFlagsPatch.RuntimeFlagsPatch): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, update: RuntimeFlagsPatch.RuntimeFlagsPatch): Effect<R, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category runtime
+ */
+export declare const withRuntimeFlagsPatchScoped: (update: RuntimeFlagsPatch.RuntimeFlagsPatch) => Effect<Scope.Scope, never, void>;
+/**
+ * Tags each metric in this effect with the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+export declare const tagMetrics: {
+    (key: string, value: string): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, key: string, value: string): Effect<R, E, A>;
+};
+/**
+ * Tags each metric in this effect with the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+export declare const labelMetrics: {
+    (labels: Iterable<MetricLabel.MetricLabel>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, labels: Iterable<MetricLabel.MetricLabel>): Effect<R, E, A>;
+};
+/**
+ * Tags each metric in this effect with the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+export declare const labelMetricsSet: {
+    (labels: HashSet.HashSet<MetricLabel.MetricLabel>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, labels: HashSet.HashSet<MetricLabel.MetricLabel>): Effect<R, E, A>;
+};
+/**
+ * Tags each metric in a scope with a the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+export declare const tagMetricsScoped: (key: string, value: string) => Effect<Scope.Scope, never, void>;
+/**
+ * Tags each metric in a scope with a the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+export declare const labelMetricsScoped: (labels: ReadonlyArray<MetricLabel.MetricLabel>) => Effect<Scope.Scope, never, void>;
+/**
+ * Tags each metric in a scope with a the specific tag.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+export declare const labelMetricsScopedSet: (labels: HashSet.HashSet<MetricLabel.MetricLabel>) => Effect<Scope.Scope, never, void>;
+/**
+ * Retrieves the metric labels associated with the current scope.
+ *
+ * @since 1.0.0
+ * @category metrics
+ */
+export declare const metricLabels: Effect<never, never, HashSet.HashSet<MetricLabel.MetricLabel>>;
+/**
+ * @since 1.0.0
+ * @category metrics
+ */
+export declare const withMetric: {
+    <Type, In, Out>(metric: Metric.Metric<Type, In, Out>): <R, E, A extends In>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A extends In, Type, In, Out>(self: Effect<R, E, A>, metric: Metric.Metric<Type, In, Out>): Effect<R, E, A>;
+};
+/**
+ * Used to unify functions that would otherwise return `Effect<A, B, C> | Effect<D, E, F>`
+ *
+ * @category unify
+ * @since 1.0.0
+ */
+export declare const unifiedFn: <Args extends ReadonlyArray<any>, Ret extends Effect<any, any, any>>(f: (...args: Args) => Ret) => (...args: Args) => Effect.Unify<Ret>;
+/**
+ * Used to unify effects that would otherwise be `Effect<A, B, C> | Effect<D, E, F>`
+ *
+ * @category unify
+ * @since 1.0.0
+ */
+export declare const unified: <Ret extends Effect<any, any, any>>(f: Ret) => Effect.Unify<Ret>;
+/**
+ * @category semaphore
+ * @since 1.0.0
+ */
+export interface Permit {
+    readonly index: number;
+}
+/**
+ * @category semaphore
+ * @since 1.0.0
+ */
+export interface Semaphore {
+    readonly withPermits: (permits: number) => <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    readonly take: (permits: number) => Effect<never, never, number>;
+    readonly release: (permits: number) => Effect<never, never, void>;
+}
+/**
+ * Unsafely creates a new Semaphore
+ *
+ * @since 1.0.0
+ * @category semaphore
+ */
+export declare const unsafeMakeSemaphore: (permits: number) => Semaphore;
+/**
+ * Creates a new Semaphore
+ *
+ * @since 1.0.0
+ * @category semaphore
+ */
+export declare const makeSemaphore: (permits: number) => Effect<never, never, Semaphore>;
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+export declare const runFork: <E, A>(effect: Effect<never, E, A>) => Fiber.RuntimeFiber<E, A>;
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+export declare const runCallback: <E, A>(effect: Effect<never, E, A>, onExit?: (exit: Exit.Exit<E, A>) => void) => Runtime.Cancel<E, A>;
+/**
+ * Runs an `Effect` workflow, returning a `Promise` which resolves with the
+ * result of the workflow or rejects with an error.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+export declare const runPromise: <E, A>(effect: Effect<never, E, A>) => Promise<A>;
+/**
+ * Runs an `Effect` workflow, returning a `Promise` which resolves with the
+ * `Exit` value of the workflow.
+ *
+ * @since 1.0.0
+ * @category execution
+ */
+export declare const runPromiseExit: <E, A>(effect: Effect<never, E, A>) => Promise<Exit.Exit<E, A>>;
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+export declare const runSync: <E, A>(effect: Effect<never, E, A>) => A;
+/**
+ * @since 1.0.0
+ * @category execution
+ */
+export declare const runSyncExit: <E, A>(effect: Effect<never, E, A>) => Exit.Exit<E, A>;
+/**
+ * Sequentially zips the this result with the specified result. Combines both
+ * `Cause`s when both effects fail.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const validate: {
+    <R1, E1, B>(that: Effect<R1, E1, B>, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | E, [A, B]>;
+    <R, E, A, R1, E1, B>(self: Effect<R, E, A>, that: Effect<R1, E1, B>, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R | R1, E | E1, [A, B]>;
+};
+/**
+ * Sequentially zips this effect with the specified effect using the specified
+ * combiner function. Combines the causes in case both effect fail.
+ *
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const validateWith: {
+    <A, R1, E1, B, C>(that: Effect<R1, E1, B>, f: (a: A, b: B) => C, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): <R, E>(self: Effect<R, E, A>) => Effect<R1 | R, E1 | E, C>;
+    <R, E, A, R1, E1, B, C>(self: Effect<R, E, A>, that: Effect<R1, E1, B>, f: (a: A, b: B) => C, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R | R1, E | E1, C>;
+};
+/**
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zip: {
+    <R2, E2, A2>(that: Effect<R2, E2, A2>, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, [A, A2]>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R | R2, E | E2, [A, A2]>;
+};
+/**
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipLeft: {
+    <R2, E2, A2>(that: Effect<R2, E2, A2>, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R | R2, E | E2, A>;
+};
+/**
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipRight: {
+    <R2, E2, A2>(that: Effect<R2, E2, A2>, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, A2>;
+    <R, E, A, R2, E2, A2>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R | R2, E | E2, A2>;
+};
+/**
+ * @since 1.0.0
+ * @category zipping
+ */
+export declare const zipWith: {
+    <R2, E2, A2, A, B>(that: Effect<R2, E2, A2>, f: (a: A, b: A2) => B, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): <R, E>(self: Effect<R, E, A>) => Effect<R2 | R, E2 | E, B>;
+    <R, E, A, R2, E2, A2, B>(self: Effect<R, E, A>, that: Effect<R2, E2, A2>, f: (a: A, b: A2) => B, options?: {
+        readonly concurrent?: boolean;
+        readonly batching?: boolean | "inherit";
+    }): Effect<R | R2, E | E2, B>;
+};
+/**
+ * @category requests & batching
+ * @since 1.0.0
+ */
+export declare const blocked: <R, E, A>(blockedRequests: RequestBlock<R>, _continue: Effect<R, E, A>) => Blocked<R, E, A>;
+/**
+ * @category requests & batching
+ * @since 1.0.0
+ */
+export declare const runRequestBlock: <R>(blockedRequests: RequestBlock<R>) => Blocked<R, never, void>;
+/**
+ * @category requests & batching
+ * @since 1.0.0
+ */
+export declare const step: <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, Exit.Exit<E, A> | Blocked<R, E, A>>;
+/**
+ * @category requests & batching
+ * @since 1.0.0
+ */
+export declare const flatMapStep: <R, E, A, R1, E1, B>(self: Effect<R, E, A>, f: (step: Exit.Exit<E, A> | Blocked<R, E, A>) => Effect<R1, E1, B>) => Effect<R | R1, E1, B>;
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+export declare const request: {
+    <A extends Request.Request<any, any>, Ds extends RequestResolver<A, never> | Effect<any, any, RequestResolver<A, never>>>(request: A, dataSource: Ds): Effect<[
+        Ds
+    ] extends [Effect<any, any, any>] ? Effect.Context<Ds> : never, Request.Request.Error<A>, Request.Request.Success<A>>;
+};
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+export declare const cacheRequestResult: <A extends Request.Request<any, any>>(request: A, result: Request.Request.Result<A>) => Effect<never, never, void>;
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+export declare const withRequestBatching: {
+    (requestBatching: boolean): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, requestBatching: boolean): Effect<R, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+export declare const setRequestBatching: (requestBatching: boolean) => Layer.Layer<never, never, never>;
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+export declare const setRequestCaching: (requestCaching: boolean) => Layer.Layer<never, never, never>;
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+export declare const setRequestCache: {
+    <R, E>(cache: Effect<R, E, Request.Cache>): Layer.Layer<Exclude<R, Scope.Scope>, E, never>;
+    (cache: Request.Cache): Layer.Layer<never, never, never>;
+};
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+export declare const withRequestCaching: {
+    (strategy: boolean): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, strategy: boolean): Effect<R, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category requests & batching
+ */
+export declare const withRequestCache: {
+    (cache: Request.Cache): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, cache: Request.Cache): Effect<R, E, A>;
+};
+/**
+ * Create a Layer that sets the current Tracer
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const setTracer: (tracer: Tracer.Tracer) => Layer.Layer<never, never, never>;
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const tracer: Effect<never, never, Tracer.Tracer>;
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const tracerWith: <R, E, A>(f: (tracer: Tracer.Tracer) => Effect<R, E, A>) => Effect<R, E, A>;
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const withTracer: {
+    (value: Tracer.Tracer): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, value: Tracer.Tracer): Effect<R, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const withTracerScoped: (value: Tracer.Tracer) => Effect<Scope.Scope, never, void>;
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const withTracerTiming: {
+    (enabled: boolean): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, enabled: boolean): Effect<R, E, A>;
+};
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const setTracerTiming: (enabled: boolean) => Layer.Layer<never, never, never>;
+/**
+ * Adds an annotation to each span in this effect.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const annotateSpans: {
+    (key: string, value: Tracer.AttributeValue): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    (values: Record<string, Tracer.AttributeValue>): <R, E, A>(effect: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, key: string, value: Tracer.AttributeValue): Effect<R, E, A>;
+    <R, E, A>(effect: Effect<R, E, A>, values: Record<string, Tracer.AttributeValue>): Effect<R, E, A>;
+};
+/**
+ * Adds an annotation to the current span if available
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const annotateCurrentSpan: {
+    (key: string, value: Tracer.AttributeValue): Effect<never, never, void>;
+    (values: Record<string, Tracer.AttributeValue>): Effect<never, never, void>;
+};
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const currentSpan: Effect<never, never, Option.Option<Tracer.Span>>;
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const currentParentSpan: Effect<never, never, Option.Option<Tracer.ParentSpan>>;
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const spanAnnotations: Effect<never, never, HashMap.HashMap<string, Tracer.AttributeValue>>;
+/**
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const spanLinks: Effect<never, never, Chunk.Chunk<Tracer.SpanLink>>;
+/**
+ * For all spans in this effect, add a link with the provided span.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const linkSpans: {
+    (span: Tracer.ParentSpan, attributes?: Record<string, Tracer.AttributeValue>): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, span: Tracer.ParentSpan, attributes?: Record<string, Tracer.AttributeValue>): Effect<R, E, A>;
+};
+/**
+ * Create a new span for tracing.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const makeSpan: (name: string, options?: {
+    readonly attributes?: Record<string, Tracer.AttributeValue>;
+    readonly links?: ReadonlyArray<Tracer.SpanLink>;
+    readonly parent?: Tracer.ParentSpan;
+    readonly root?: boolean;
+    readonly context?: Context.Context<never>;
+}) => Effect<never, never, Tracer.Span>;
+/**
+ * Adds the provided span to the span stack.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const setParentSpan: (span: Tracer.ParentSpan) => Layer.Layer<never, never, never>;
+/**
+ * Create and add a span to the current span stack.
+ *
+ * The span is ended when the Layer is released.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const setSpan: (name: string, options?: {
+    readonly attributes?: Record<string, Tracer.AttributeValue>;
+    readonly links?: ReadonlyArray<Tracer.SpanLink>;
+    readonly parent?: Tracer.ParentSpan;
+    readonly root?: boolean;
+    readonly context?: Context.Context<never>;
+}) => Layer.Layer<never, never, never>;
+/**
+ * Create a new span for tracing, and automatically close it when the effect
+ * completes.
+ *
+ * The span is not added to the current span stack, so no child spans will be
+ * created for it.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const useSpan: {
+    <R, E, A>(name: string, evaluate: (span: Tracer.Span) => Effect<R, E, A>): Effect<R, E, A>;
+    <R, E, A>(name: string, options: {
+        readonly attributes?: Record<string, Tracer.AttributeValue>;
+        readonly links?: ReadonlyArray<Tracer.SpanLink>;
+        readonly parent?: Tracer.ParentSpan;
+        readonly root?: boolean;
+        readonly context?: Context.Context<never>;
+    }, evaluate: (span: Tracer.Span) => Effect<R, E, A>): Effect<R, E, A>;
+};
+/**
+ * Create a new span for tracing, and automatically close it when the Scope
+ * finalizes.
+ *
+ * The span is not added to the current span stack, so no child spans will be
+ * created for it.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const useSpanScoped: (name: string, options?: {
+    readonly attributes?: Record<string, Tracer.AttributeValue>;
+    readonly links?: ReadonlyArray<Tracer.SpanLink>;
+    readonly parent?: Tracer.ParentSpan;
+    readonly root?: boolean;
+    readonly context?: Context.Context<never>;
+}) => Effect<Scope.Scope, never, Tracer.Span>;
+/**
+ * Wraps the effect with a new span for tracing.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const withSpan: {
+    (name: string, options?: {
+        readonly attributes?: Record<string, Tracer.AttributeValue>;
+        readonly links?: ReadonlyArray<Tracer.SpanLink>;
+        readonly parent?: Tracer.ParentSpan;
+        readonly root?: boolean;
+        readonly context?: Context.Context<never>;
+    }): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, name: string, options?: {
+        readonly attributes?: Record<string, Tracer.AttributeValue>;
+        readonly links?: ReadonlyArray<Tracer.SpanLink>;
+        readonly parent?: Tracer.ParentSpan;
+        readonly root?: boolean;
+        readonly context?: Context.Context<never>;
+    }): Effect<R, E, A>;
+};
+/**
+ * Create and add a span to the current span stack.
+ *
+ * The span is ended when the Scope is finalized.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const withSpanScoped: (name: string, options?: {
+    readonly attributes?: Record<string, Tracer.AttributeValue>;
+    readonly links?: ReadonlyArray<Tracer.SpanLink>;
+    readonly parent?: Tracer.ParentSpan;
+    readonly root?: boolean;
+    readonly context?: Context.Context<never>;
+}) => Effect<Scope.Scope, never, void>;
+/**
+ * Adds the provided span to the current span stack.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const withParentSpan: {
+    (span: Tracer.ParentSpan): <R, E, A>(self: Effect<R, E, A>) => Effect<R, E, A>;
+    <R, E, A>(self: Effect<R, E, A>, span: Tracer.ParentSpan): Effect<R, E, A>;
+};
+/**
+ * Adds the provided span to the current span stack.
+ *
+ * @since 1.0.0
+ * @category tracing
+ */
+export declare const withParentSpanScoped: (span: Tracer.ParentSpan) => Effect<Scope.Scope, never, void>;
+/**
+ * Returns an effect that errors with `NoSuchElementException` if the value is
+ * null or undefined, otherwise succeeds with the value.
+ *
+ * @since 1.0.0
+ * @category optionality
+ */
+export declare const fromNullable: <A>(value: A) => Effect<never, Cause.NoSuchElementException, NonNullable<A>>;
+/**
+ * Wraps the success value of this effect with `Option.some`, and maps
+ * `Cause.NoSuchElementException` to `Option.none`.
+ *
+ * @since 1.0.0
+ * @category optionality
+ */
+export declare const optionFromOptional: <R, E, A>(self: Effect<R, E, A>) => Effect<R, Exclude<E, Cause.NoSuchElementException>, Option.Option<A>>;
+//# sourceMappingURL=Effect.d.ts.map