import type { Async } from "@effect-ts/core/Async";
import type { Chunk } from "@effect-ts/core/Collections/Immutable/Chunk";
import type { NonEmptyArray } from "@effect-ts/core/Collections/Immutable/NonEmptyArray";
import type { SortedSet } from "@effect-ts/core/Collections/Immutable/SortedSet";
import type * as Tp from "@effect-ts/core/Collections/Immutable/Tuple";
import type * as T from "@effect-ts/core/Effect";
import type { Cause } from "@effect-ts/core/Effect/Cause";
import type { Clock, HasClock } from "@effect-ts/core/Effect/Clock";
import type { Exit } from "@effect-ts/core/Effect/Exit";
import type * as Fiber from "@effect-ts/core/Effect/Fiber";
import type { Layer } from "@effect-ts/core/Effect/Layer";
import type * as M from "@effect-ts/core/Effect/Managed";
import type * as P from "@effect-ts/core/Effect/Promise";
import type { Schedule } from "@effect-ts/core/Effect/Schedule";
import type { Scope } from "@effect-ts/core/Effect/Scope";
import type { Supervisor } from "@effect-ts/core/Effect/Supervisor";
import type * as E from "@effect-ts/core/Either";
import type { Lazy, Predicate, Refinement } from "@effect-ts/core/Function";
import type { Has, Tag } from "@effect-ts/core/Has";
import type * as IO from "@effect-ts/core/IO";
import type * as O from "@effect-ts/core/Option";
import type { _A, _E, _R, Compute, EnforceNonEmptyRecord, Erase, ForcedArray, Separated } from "@effect-ts/core/Utils";
import type { NoSuchElementException } from "@effect-ts/system/GlobalExceptions";
declare module "@effect-ts/system/Effect/effect" {
    const Effect: EffectStaticOps;
    interface EffectStaticOps {
        /**
         * @ets_rewrite_static access from "@effect-ts/core/Effect"
         */
        access: typeof T.access;
        /**
         * @ets_rewrite_static accessM from "@effect-ts/core/Effect"
         */
        accessM: typeof T.accessM;
        /**
         * @ets_rewrite_static accessServiceM from "@effect-ts/core/Effect"
         */
        accessServiceM: typeof T.accessServiceM;
        /**
         * @ets_rewrite_static accessService from "@effect-ts/core/Effect"
         */
        accessService: typeof T.accessService;
        /**
         * @ets_rewrite_static accessServices from "@effect-ts/core/Effect"
         */
        accessServices: typeof T.accessServices;
        /**
         * @ets_rewrite_static accessServices from "@effect-ts/core/Effect"
         */
        accessServicesM: typeof T.accessServicesM;
        /**
         * @ets_rewrite_static accessServicesT from "@effect-ts/core/Effect"
         */
        accessServicesT: typeof T.accessServicesT;
        /**
         * @ets_rewrite_static accessServicesTM from "@effect-ts/core/Effect"
         */
        accessServicesTM: typeof T.accessServicesTM;
        /**
         * @ets_rewrite_static collect from "@effect-ts/core/Effect"
         * @ets_data_first collect_
         */
        collect<A, R, E, B>(f: (a: A) => T.Effect<R, O.Option<E>, B>, __trace?: string | undefined): (self: Iterable<A>) => T.Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collect_ from "@effect-ts/core/Effect"
         */
        collect<A, R, E, B>(self: Iterable<A>, f: (a: A) => T.Effect<R, O.Option<E>, B>, __trace?: string | undefined): T.Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectAll from "@effect-ts/core/Effect"
         */
        collectAll: typeof T.collectAll;
        /**
         * @ets_rewrite_static collectAllPar from "@effect-ts/core/Effect"
         */
        collectAllPar: typeof T.collectAllPar;
        /**
         * @ets_rewrite_static collectAllPar from "@effect-ts/core/Effect"
         * @ets_data_first collectAllParN_
         */
        collectAllParN(n: number, __trace?: string | undefined): <R, E, A>(as: Iterable<Effect<R, E, A>>) => Effect<R, E, Chunk<A>>;
        /**
         * @ets_rewrite_static collectAllParN_ from "@effect-ts/core/Effect"
         */
        collectAllParN<R, E, A>(as: Iterable<Effect<R, E, A>>, n: number, __trace?: string | undefined): Effect<R, E, Chunk<A>>;
        /**
         * @ets_rewrite_static collectAllSuccesses from "@effect-ts/core/Effect"
         */
        collectAllSuccesses: typeof T.collectAllSuccesses;
        /**
         * @ets_rewrite_static collectAllSuccessesPar from "@effect-ts/core/Effect"
         */
        collectAllSuccessesPar: typeof T.collectAllSuccessesPar;
        /**
         * @ets_rewrite_static collectAllSuccessesPar from "@effect-ts/core/Effect"
         */
        collectAllSuccessesParN: typeof T.collectAllSuccessesParN;
        /**
         * @ets_rewrite_static collectAllUnit from "@effect-ts/core/Effect"
         */
        collectAllUnit: typeof T.collectAllUnit;
        /**
         * @ets_rewrite_static collectAllUnit from "@effect-ts/core/Effect"
         */
        collectAllUnitPar: typeof T.collectAllUnitPar;
        /**
         * @ets_rewrite_static collectAllUnitParN from "@effect-ts/core/Effect"
         * @ets_data_first collectAllUnitParN_
         */
        collectAllUnitParN(n: number, __trace?: string | undefined): <R, E, A>(as: Iterable<Effect<R, E, A>>) => Effect<R, E, void>;
        /**
         * @ets_rewrite_static collectAllUnitParN_ from "@effect-ts/core/Effect"
         */
        collectAllUnitParN<R, E, A>(as: Iterable<Effect<R, E, A>>, n: number, __trace?: string | undefined): Effect<R, E, void>;
        /**
         * @ets_rewrite_static collectAllWith from "@effect-ts/core/Effect"
         * @ets_data_first collectAllWith_
         */
        collectAllWith<A, B>(pf: (a: A) => O.Option<B>, __trace?: string | undefined): <R, E>(as: Iterable<Effect<R, E, A>>) => Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectAllWith_ from "@effect-ts/core/Effect"
         */
        collectAllWith<R, E, A, B>(as: Iterable<Effect<R, E, A>>, pf: (a: A) => O.Option<B>, __trace?: string | undefined): Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectAllWithPar from "@effect-ts/core/Effect"
         * @ets_data_first collectAllWithPar_
         */
        collectAllWithPar<A, B>(pf: (a: A) => O.Option<B>, __trace?: string | undefined): <R, E>(as: Iterable<Effect<R, E, A>>) => Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectAllWithPar_ from "@effect-ts/core/Effect"
         */
        collectAllWithPar<R, E, A, B>(as: Iterable<Effect<R, E, A>>, pf: (a: A) => O.Option<B>, __trace?: string | undefined): Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectAllWithParN from "@effect-ts/core/Effect"
         * @ets_data_first collectAllWithParN_
         */
        collectAllWithParN<A, B>(n: number, pf: (a: A) => O.Option<B>, __trace?: string | undefined): <R, E>(as: Iterable<Effect<R, E, A>>) => Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectAllWithParN_ from "@effect-ts/core/Effect"
         */
        collectAllWithParN<R, E, A, B>(as: Iterable<Effect<R, E, A>>, n: number, pf: (a: A) => O.Option<B>, __trace?: string | undefined): Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectPar from "@effect-ts/core/Effect"
         * @ets_data_first collectPar_
         */
        collectPar<A, R, E, B>(f: (a: A) => T.Effect<R, O.Option<E>, B>, __trace?: string | undefined): (self: Iterable<A>) => T.Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectPar_ from "@effect-ts/core/Effect"
         */
        collectPar<A, R, E, B>(self: Iterable<A>, f: (a: A) => T.Effect<R, O.Option<E>, B>, __trace?: string | undefined): T.Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectParN from "@effect-ts/core/Effect"
         * @ets_data_first collectParN_
         */
        collectParN<A, R, E, B>(n: number, f: (a: A) => T.Effect<R, O.Option<E>, B>, __trace?: string | undefined): (self: Iterable<A>) => T.Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static collectParN_ from "@effect-ts/core/Effect"
         */
        collectParN<A, R, E, B>(self: Iterable<A>, n: number, f: (a: A) => T.Effect<R, O.Option<E>, B>, __trace?: string | undefined): T.Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static cond from "@effect-ts/core/Effect"
         * @ets_data_first cond_
         */
        cond<E, A>(onTrue: () => A, onFalse: () => E, __trace?: string | undefined): (b: boolean) => T.Effect<unknown, E, A>;
        /**
         * @ets_rewrite_static cond_ from "@effect-ts/core/Effect"
         */
        cond<E, A>(b: boolean, onTrue: () => A, onFalse: () => E, __trace?: string | undefined): T.Effect<unknown, E, A>;
        /**
         * @ets_rewrite_static condM from "@effect-ts/core/Effect"
         * @ets_data_first condM_
         */
        condM<R, R2, E, A>(onTrue: T.RIO<R, A>, onFalse: T.RIO<R2, E>, __trace?: string | undefined): (b: boolean) => T.Effect<R & R2, E, A>;
        /**
         * @ets_rewrite_static condM_ from "@effect-ts/core/Effect"
         */
        condM<R, R2, E, A>(b: boolean, onTrue: T.RIO<R, A>, onFalse: T.RIO<R2, E>, __trace?: string | undefined): T.Effect<R & R2, E, A>;
        /**
         * @ets_rewrite_static Applicative from "@effect-ts/core/Effect"
         */
        descriptor: typeof T.descriptor;
        /**
         * @ets_rewrite_static descriptorWith from "@effect-ts/core/Effect"
         */
        descriptorWith: typeof T.descriptorWith;
        /**
         * @ets_rewrite_static dropWhile from "@effect-ts/core/Effect"
         * @ets_data_first dropWhile_
         */
        dropWhile<A, R, E>(p: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, E, Array<A>>;
        /**
         * @ets_rewrite_static dropWhile_ from "@effect-ts/core/Effect"
         */
        dropWhile<A, R, E>(as: Iterable<A>, p: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): T.Effect<R, E, Array<A>>;
        /**
         * @ets_rewrite_static Applicative from "@effect-ts/core/Effect"
         */
        Applicative: typeof T.Applicative;
        /**
         * @ets_rewrite_static effectAsyncInterrupt from "@effect-ts/core/Effect"
         */
        asyncInterrupt<R, E, A>(register: (cb: T.Cb<Effect<R, E, A>>) => T.Canceler<R>, __trace?: string | undefined): Effect<R, E, A>;
        /**
         * @ets_rewrite_static effectAsyncInterruptBlockingOn from "@effect-ts/core/Effect"
         */
        asyncInterrupt<R, E, A>(register: (cb: T.Cb<T.Effect<R, E, A>>) => T.Canceler<R>, blockingOn: readonly Fiber.FiberID[], __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static effectAsync from "@effect-ts/core/Effect"
         */
        async<R, E, A>(register: (cb: T.Cb<Effect<R, E, A>>) => void, __trace?: string | undefined): Effect<R, E, A>;
        /**
         * @ets_rewrite_static effectAsyncBlockingOn from "@effect-ts/core/Effect"
         */
        async<R, E, A>(register: (cb: T.Cb<T.Effect<R, E, A>>) => void, blockingOn: readonly Fiber.FiberID[], __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static effectAsyncM from "@effect-ts/core/Effect"
         */
        asyncEffect<R, E, R2, E2, A, X>(register: (cb: (_: T.Effect<R2, E2, A>) => void) => T.Effect<R, E, X>, __trace?: string | undefined): T.Effect<R & R2, E | E2, A>;
        /**
         * @ets_rewrite_static effectAsyncOption from "@effect-ts/core/Effect"
         */
        asyncOption<R, E, A>(register: (cb: (_: T.Effect<R, E, A>) => void) => O.Option<T.Effect<R, E, A>>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static effectAsyncOptionBlockingOn from "@effect-ts/core/Effect"
         */
        asyncOption<R, E, A>(register: (cb: (_: Effect<R, E, A>) => void) => O.Option<Effect<R, E, A>>, blockingOn: readonly Fiber.FiberID[], __trace?: string): Effect<R, E, A>;
        /**
         * @ets_rewrite_static effectMaybeAsyncInterrupt from "@effect-ts/core/Effect"
         */
        asyncOptionInterrupt<R, E, A>(register: (cb: T.Cb<T.Effect<R, E, A>>) => E.Either<T.Canceler<R>, T.Effect<R, E, A>>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static effectMaybeAsyncInterruptBlockingOn from "@effect-ts/core/Effect"
         */
        asyncOptionInterrupt<R, E, A>(register: (cb: T.Cb<Effect<R, E, A>>) => E.Either<T.Canceler<R>, Effect<R, E, A>>, blockingOn: readonly Fiber.FiberID[], __trace?: string): Effect<R, E, A>;
        /**
         * @ets_rewrite_static do from "@effect-ts/core/Effect"
         */
        do_: typeof T.do;
        /**
         * @ets_rewrite_static deriveLifted from "@effect-ts/core/Effect"
         */
        deriveLifted: typeof T.deriveLifted;
        /**
         * @ets_rewrite_static done from "@effect-ts/core/Effect"
         */
        done: typeof T.done;
        /**
         * @ets_rewrite_static dieWith from "@effect-ts/core/Effect"
         */
        die: typeof T.dieWith;
        /**
         * @ets_rewrite_static die from "@effect-ts/core/Effect"
         */
        dieNow: typeof T.die;
        /**
         * @ets_rewrite_static defaultEnv from "@effect-ts/core/Effect"
         */
        defaultEnv: typeof T.defaultEnv;
        /**
         * @ets_rewrite_static defaultPlatform from "@effect-ts/core/Effect"
         */
        defaultPlatform: typeof T.defaultPlatform;
        /**
         * @ets_rewrite_static environment from "@effect-ts/core/Effect"
         */
        environment: typeof T.environment;
        /**
         * @ets_rewrite_static forEach_ from "@effect-ts/core/Effect"
         */
        forEach<A, R, E, B>(as: Iterable<A>, f: (a: A) => Effect<R, E, B>, __trace?: string | undefined): Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static forEach from "@effect-ts/core/Effect"
         * @ets_data_first forEach_
         */
        forEach<A, R, E, B>(f: (a: A) => Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static forEachPar_ from "@effect-ts/core/Effect"
         */
        forEachPar<A, R, E, B>(as: Iterable<A>, f: (a: A) => Effect<R, E, B>, __trace?: string | undefined): Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static forEachPar from "@effect-ts/core/Effect"
         * @ets_data_first forEachPar_
         */
        forEachPar<A, R, E, B>(f: (a: A) => Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static forEachParN_ from "@effect-ts/core/Effect"
         */
        forEachParN<A, R, E, B>(as: Iterable<A>, n: number, f: (a: A) => Effect<R, E, B>, __trace?: string | undefined): Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static forEachParN from "@effect-ts/core/Effect"
         * @ets_data_first forEachParN_
         */
        forEachParN<A, R, E, B>(n: number, f: (a: A) => Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static failWith from "@effect-ts/core/Effect"
         */
        fail: typeof T.failWith;
        /**
         * @ets_rewrite_static fail from "@effect-ts/core/Effect"
         */
        failNow: typeof T.fail;
        /**
         * @ets_rewrite_static filter from "@effect-ts/core/Effect"
         * @ets_data_first filter_
         */
        filter<A, R, E>(f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, E, readonly A[]>;
        /**
         * @ets_rewrite_static filter_ from "@effect-ts/core/Effect"
         */
        filter<A, R, E>(as: Iterable<A>, f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): T.Effect<R, E, readonly A[]>;
        /**
         * @ets_rewrite_static filterNot from "@effect-ts/core/Effect"
         * @ets_data_first filterNot_
         */
        filterNot<A, R, E>(f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, E, readonly A[]>;
        /**
         * @ets_rewrite_static filterNot_ from "@effect-ts/core/Effect"
         */
        filterNot<A, R, E>(as: Iterable<A>, f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): T.Effect<R, E, readonly A[]>;
        /**
         * @ets_rewrite_static filterNotPar from "@effect-ts/core/Effect"
         * @ets_data_first filterNotPar_
         */
        filterNotPar<A, R, E>(f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, E, readonly A[]>;
        /**
         * @ets_rewrite_static filterNotPar_ from "@effect-ts/core/Effect"
         */
        filterNotPar<A, R, E>(as: Iterable<A>, f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): T.Effect<R, E, readonly A[]>;
        /**
         * @ets_rewrite_static filterNotParN from "@effect-ts/core/Effect"
         * @ets_data_first filterNotParN_
         */
        filterNotParN<R, E, A>(n: number, f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, E, Chunk<A>>;
        /**
         * @ets_rewrite_static filterNotParN_ from "@effect-ts/core/Effect"
         */
        filterNotParN<A, R, E>(as: Iterable<A>, n: number, f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): T.Effect<R, E, Chunk<A>>;
        /**
         * @ets_rewrite_static filterPar from "@effect-ts/core/Effect"
         * @ets_data_first filterPar_
         */
        filterPar<A, R, E>(f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, E, readonly A[]>;
        /**
         * @ets_rewrite_static filterPar_ from "@effect-ts/core/Effect"
         */
        filterPar<A, R, E>(as: Iterable<A>, f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): T.Effect<R, E, readonly A[]>;
        /**
         * @ets_rewrite_static filterParN from "@effect-ts/core/Effect"
         * @ets_data_first filterParN_
         */
        filterParN<A, R, E>(n: number, f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, E, Chunk<A>>;
        /**
         * @ets_rewrite_static filterParN_ from "@effect-ts/core/Effect"
         */
        filterParN<A, R, E>(as: Iterable<A>, n: number, f: (a: A) => T.Effect<R, E, boolean>, __trace?: string | undefined): T.Effect<R, E, Chunk<A>>;
        /**
         * @ets_rewrite_static forEachExec from "@effect-ts/core/Effect"
         * @ets_data_first forEachExec_
         */
        forEachExec<R, E, A, B>(es: T.ExecutionStrategy, f: (a: A) => Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static forEachExec_ from "@effect-ts/core/Effect"
         */
        forEachExec<R, E, A, B>(as: Iterable<A>, es: T.ExecutionStrategy, f: (a: A) => Effect<R, E, B>, __trace?: string | undefined): Effect<R, E, Chunk<B>>;
        /**
         * @ets_rewrite_static first from "@effect-ts/core/Effect"
         */
        first: typeof T.first;
        /**
         * @ets_rewrite_static forkAll from "@effect-ts/core/Effect"
         */
        forkAll: typeof T.forkAll;
        /**
         * @ets_rewrite_static forkAllUnit from "@effect-ts/core/Effect"
         */
        forkAllUnit: typeof T.forkAllUnit;
        /**
         * @ets_rewrite_static forkScope from "@effect-ts/core/Effect"
         */
        forkScope: typeof T.forkScope;
        /**
         * @ets_rewrite_static forkScopeMask from "@effect-ts/core/Effect"
         * @ets_data_first forkScopeMask_
         */
        forkScopeMask<R, E, A>(f: (restore: T.ForkScopeRestore) => T.Effect<R, E, A>, __trace?: string | undefined): (newScope: Scope<Exit<any, any>>) => T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static forkScopeMask_ from "@effect-ts/core/Effect"
         */
        forkScopeMask<R, E, A>(newScope: Scope<Exit<any, any>>, f: (restore: T.ForkScopeRestore) => T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static forkScope from "@effect-ts/core/Effect"
         */
        forkScopeWith: typeof T.forkScopeWith;
        /**
         * @ets_rewrite_static firstSuccessOf from "@effect-ts/core/Effect"
         */
        firstSuccessOf: typeof T.firstSuccessOf;
        /**
         * @ets_rewrite_static fromAsync from "@effect-ts/core/Effect"
         */
        from<R, E, A>(async: Async<R, E, A>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static fromEither from "@effect-ts/core/Effect"
         */
        from<E, A>(f: () => E.Either<E, A>, __trace?: string | undefined): T.Effect<unknown, E, A>;
        /**
         * @ets_rewrite_static fromFiber from "@effect-ts/core/Effect"
         */
        from<E, A>(fiber: () => Fiber.Fiber<E, A>, __trace?: string | undefined): T.IO<E, A>;
        /**
         * @ets_rewrite_static fromFiberM from "@effect-ts/core/Effect"
         */
        from<R, E, E2, A>(fiber: T.Effect<R, E, Fiber.Fiber<E2, A>>, __trace?: string | undefined): T.Effect<R, E | E2, A>;
        /**
         * @ets_rewrite_static fromPredicate from "@effect-ts/core/Effect"
         */
        from<E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (a: A) => IO<E, B>;
        /**
         * @ets_rewrite_static fromPredicate from "@effect-ts/core/Effect"
         */
        from<E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (a: A) => IO<E, A>;
        /**
         * @ets_rewrite_static fromIO from "@effect-ts/core/Effect"
         */
        from<A>(io: IO.IO<A>, __trace?: string | undefined): T.Effect<unknown, never, A>;
        /**
         * @ets_rewrite_static fromNodeCb from "@effect-ts/core/Effect"
         */
        from<L, R>(f: (this: unknown, cb: (e: L | null | undefined, r?: R) => void) => void, __trace?: string): () => IO<L, R>;
        /**
         * @ets_rewrite_static fromNodeCb from "@effect-ts/core/Effect"
         */
        from<A, L, R>(f: (this: unknown, a: A, cb: (e: L | null | undefined, r?: R) => void) => void, __trace?: string): (a: A) => IO<L, R>;
        /**
         * @ets_rewrite_static fromNodeCb from "@effect-ts/core/Effect"
         */
        from<A, B, L, R>(f: (this: unknown, a: A, b: B, cb: (e: L | null | undefined, r?: R) => void) => void, __trace?: string): (a: A, b: B) => IO<L, R>;
        /**
         * @ets_rewrite_static fromNodeCb from "@effect-ts/core/Effect"
         */
        from<A, B, C, L, R>(f: (this: unknown, a: A, b: B, c: C, cb: (e: L | null | undefined, r?: R) => void) => void, __trace?: string): (a: A, b: B, c: C) => IO<L, R>;
        /**
         * @ets_rewrite_static fromNodeCb from "@effect-ts/core/Effect"
         */
        from<A, B, C, D, L, R>(f: (this: unknown, a: A, b: B, c: C, d: D, cb: (e: L | null | undefined, r?: R) => void) => void, __trace?: string): (a: A, b: B, c: C, d: D) => IO<L, R>;
        /**
         * @ets_rewrite_static fromNodeCb from "@effect-ts/core/Effect"
         */
        from<A, B, C, D, E, L, R>(f: (this: unknown, a: A, b: B, c: C, d: D, e: E, cb: (e: L | null | undefined, r?: R) => void) => void, __trace?: string): (a: A, b: B, c: C, d: D, e: E) => IO<L, R>;
        /**
         * @ets_rewrite_static fromNodeCb from "@effect-ts/core/Effect"
         */
        from<A extends any[], L, R>(f: (this: unknown, ...args: [...A, (e: L | null | undefined, r?: R) => void]) => void, __trace?: string): (...args: A) => IO<L, R>;
        /**
         * @ets_rewrite_static fromOption from "@effect-ts/core/Effect"
         */
        from<A>(o: O.Option<A>, __trace?: string | undefined): T.IO<O.Option<never>, A>;
        /**
         * @ets_rewrite_static fromNullable from "@effect-ts/core/Effect"
         */
        fromNullable<A>(o: A, __trace?: string | undefined): T.IO<O.Option<never>, NonNullable<A>>;
        /**
         * @ets_rewrite_static gen from "@effect-ts/core/Effect"
         */
        gen: typeof T.gen;
        /**
         * @ets_rewrite_static genM from "@effect-ts/core/Effect"
         */
        genM: typeof T.genM;
        /**
         * @ets_rewrite_static getIdentity from "@effect-ts/core/Effect"
         */
        getIdentity: typeof T.getIdentity;
        /**
         * @ets_rewrite_static getIdentityPar from "@effect-ts/core/Effect"
         */
        getIdentityPar: typeof T.getIdentityPar;
        /**
         * @ets_rewrite_static getOrFail from "@effect-ts/core/Effect"
         */
        getOrFail: typeof T.getOrFail;
        /**
         * @ets_rewrite_static getOrFailUnit from "@effect-ts/core/Effect"
         */
        getOrFailUnit: typeof T.getOrFailUnit;
        /**
         * @ets_rewrite_static getValidationApplicative from "@effect-ts/core/Effect"
         */
        getValidationApplicative: typeof T.getValidationApplicative;
        /**
         * @ets_rewrite_static haltWith from "@effect-ts/core/Effect"
         */
        halt: typeof T.haltWith;
        /**
         * @ets_rewrite_static halt from "@effect-ts/core/Effect"
         */
        haltNow: typeof T.halt;
        /**
         * @ets_rewrite_static if from "@effect-ts/core/Effect"
         * @ets_data_first if_
         */
        if<R1, E1, A1, R2, E2, A2>(onTrue: () => Effect<R1, E1, A1>, onFalse: () => Effect<R2, E2, A2>, __trace?: string | undefined): (b: boolean) => Effect<R1 & R2, E1 | E2, A1 | A2>;
        /**
         * @ets_rewrite_static if_ from "@effect-ts/core/Effect"
         */
        if<R1, E1, A1, R2, E2, A2>(b: boolean, onTrue: () => T.Effect<R1, E1, A1>, onFalse: () => T.Effect<R2, E2, A2>, __trace?: string | undefined): T.Effect<R1 & R2, E1 | E2, A1 | A2>;
        /**
         * @ets_rewrite_static interrupt from "@effect-ts/core/Effect"
         */
        interrupt: typeof T.interrupt;
        /**
         * @ets_rewrite_static interruptAs from "@effect-ts/core/Effect"
         */
        interruptAs: typeof T.interruptAs;
        /**
         * @ets_rewrite_static interruptibleMask from "@effect-ts/core/Effect"
         */
        interruptibleMask: typeof T.interruptibleMask;
        /**
         * @ets_rewrite_static iterate from "@effect-ts/core/Effect"
         */
        iterate: typeof T.iterate;
        /**
         * @ets_rewrite_static loop from "@effect-ts/core/Effect"
         */
        loop: typeof T.loop;
        /**
         * @ets_rewrite_static loopUnit from "@effect-ts/core/Effect"
         */
        loopUnit: typeof T.loopUnit;
        /**
         * @ets_rewrite_static makeCustomRuntime from "@effect-ts/core/Effect"
         */
        makeCustomRuntime: typeof T.makeCustomRuntime;
        /**
         * @ets_rewrite_static mapN from "@effect-ts/core/Effect"
         * @ets_data_first mapN_
         */
        mapN<T extends NonEmptyArray<Effect<any, any, any>>, B>(f: (..._: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): (t: Tp.Tuple<T>) => Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_static mapN_ from "@effect-ts/core/Effect"
         */
        mapN<T extends NonEmptyArray<Effect<any, any, any>>, B>(t: Tp.Tuple<T>, f: (..._: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_static mapNPar from "@effect-ts/core/Effect"
         * @ets_data_first mapNPar_
         */
        mapNPar<T extends NonEmptyArray<Effect<any, any, any>>, B>(f: (..._: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): (t: Tp.Tuple<T>) => Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_static mapNPar_ from "@effect-ts/core/Effect"
         */
        mapNPar<T extends NonEmptyArray<Effect<any, any, any>>, B>(t: Tp.Tuple<T>, f: (..._: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_static mapNParN from "@effect-ts/core/Effect"
         * @ets_data_first mapNParN_
         */
        mapNParN<T extends NonEmptyArray<Effect<any, any, any>>, B>(n: number, f: (..._: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): (t: Tp.Tuple<T>) => Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_static mapNParN_ from "@effect-ts/core/Effect"
         */
        mapNParN<T extends NonEmptyArray<Effect<any, any, any>>, B>(t: Tp.Tuple<T>, n: number, f: (..._: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_static match from "@effect-ts/core/Effect"
         */
        match: typeof T.match;
        /**
         * @ets_rewrite_static matchIn from "@effect-ts/core/Effect"
         */
        matchIn: typeof T.matchIn;
        /**
         * @ets_rewrite_static matchMorph from "@effect-ts/core/Effect"
         */
        matchMorph: typeof T.matchMorph;
        /**
         * @ets_rewrite_static matchTag from "@effect-ts/core/Effect"
         */
        matchTag: typeof T.matchTag;
        /**
         * @ets_rewrite_static matchTagIn from "@effect-ts/core/Effect"
         */
        matchTagIn: typeof T.matchTagIn;
        /**
         * @ets_rewrite_static memoize from "@effect-ts/core/Effect"
         */
        memoize: typeof T.memoize;
        /**
         * @ets_rewrite_static memoizeEq from "@effect-ts/core/Effect"
         */
        memoizeEq: typeof T.memoizeEq;
        /**
         * @ets_rewrite_static mergeAll from "@effect-ts/core/Effect"
         * @ets_data_first mergeAll_
         */
        mergeAll<A, B>(zero: B, f: (b: B, a: A) => B, __trace?: string | undefined): <R, E>(as: Iterable<T.Effect<R, E, A>>) => T.Effect<R, E, B>;
        /**
         * @ets_rewrite_static mergeAll_ from "@effect-ts/core/Effect"
         */
        mergeAll<R, E, A, B>(as: Iterable<T.Effect<R, E, A>>, zero: B, f: (b: B, a: A) => B, __trace?: string | undefined): T.Effect<R, E, B>;
        /**
         * @ets_rewrite_static mergeAllPar from "@effect-ts/core/Effect"
         * @ets_data_first mergeAllPar_
         */
        mergeAllPar<A, B>(zero: B, f: (b: B, a: A) => B, __trace?: string | undefined): <R, E>(as: Iterable<T.Effect<R, E, A>>) => T.Effect<R, E, B>;
        /**
         * @ets_rewrite_static mergeAllPar_ from "@effect-ts/core/Effect"
         */
        mergeAllPar<R, E, A, B>(as: Iterable<T.Effect<R, E, A>>, zero: B, f: (b: B, a: A) => B, __trace?: string | undefined): T.Effect<R, E, B>;
        /**
         * @ets_rewrite_static mergeAllParN from "@effect-ts/core/Effect"
         * @ets_data_first mergeAllParN_
         */
        mergeAllParN<A, B>(n: number, zero: B, f: (b: B, a: A) => B, __trace?: string | undefined): <R, E>(as: Iterable<T.Effect<R, E, A>>) => T.Effect<R, E, B>;
        /**
         * @ets_rewrite_static mergeAllParN_ from "@effect-ts/core/Effect"
         */
        mergeAllParN<R, E, A, B>(as: Iterable<T.Effect<R, E, A>>, n: number, zero: B, f: (b: B, a: A) => B, __trace?: string | undefined): T.Effect<R, E, B>;
        /**
         * @ets_rewrite_static never from "@effect-ts/core/Effect"
         */
        never: typeof T.never;
        /**
         * @ets_rewrite_static none from "@effect-ts/core/Effect"
         */
        none: typeof T.none;
        /**
         * @ets_rewrite_static parallel from "@effect-ts/core/Effect"
         */
        parallel: typeof T.parallel;
        /**
         * @ets_rewrite_static parallelN from "@effect-ts/core/Effect"
         */
        parallelN: typeof T.parallelN;
        /**
         * @ets_rewrite_static partition from "@effect-ts/core/Effect"
         * @ets_data_first partition_
         */
        partition<A, R, E, B>(f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => T.RIO<R, Separated<Iterable<E>, Iterable<B>>>;
        /**
         * @ets_rewrite_static partition_ from "@effect-ts/core/Effect"
         */
        partition<A, R, E, B>(as: Iterable<A>, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.RIO<R, Separated<Iterable<E>, Iterable<B>>>;
        /**
         * @ets_rewrite_static partitionPar from "@effect-ts/core/Effect"
         * @ets_data_first partitionPar_
         */
        partitionPar<A, R, E, B>(f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => T.RIO<R, Separated<Iterable<E>, Iterable<B>>>;
        /**
         * @ets_rewrite_static partitionPar_ from "@effect-ts/core/Effect"
         */
        partitionPar<A, R, E, B>(as: Iterable<A>, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.RIO<R, Separated<Iterable<E>, Iterable<B>>>;
        /**
         * @ets_rewrite_static partitionParN from "@effect-ts/core/Effect"
         * @ets_data_first partitionParN_
         */
        partitionParN<A, R, E, B>(n: number, f: (a: A) => Effect<R, E, B>, __trace?: string): (as: Iterable<A>) => Effect<R, never, Separated<Iterable<E>, Iterable<B>>>;
        /**
         * @ets_rewrite_static partitionParN_ from "@effect-ts/core/Effect"
         */
        partitionParN<A, R, E, B>(as: Iterable<A>, n: number, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.Effect<R, never, Separated<Iterable<E>, Iterable<B>>>;
        /**
         * @ets_rewrite_static prettyReporter from "@effect-ts/core/Effect"
         */
        prettyReporter: typeof T.prettyReporter;
        /**
         * @ets_rewrite_static promise from "@effect-ts/core/Effect"
         */
        promise<A>(effect: Lazy<Promise<A>>, __trace?: string | undefined): UIO<A>;
        /**
         * @ets_rewrite_static tryCatchPromise from "@effect-ts/core/Effect"
         */
        promise<E, A>(promise: Lazy<Promise<A>>, onReject: (reason: unknown) => E, __trace?: string | undefined): T.IO<E, A>;
        /**
         * @ets_rewrite_static provide from "@effect-ts/core/Effect"
         * @ets_data_first provide_
         */
        provide<R>(r: R, __trace?: string | undefined): <E, A, R0>(next: T.Effect<R & R0, E, A>) => T.Effect<R0, E, A>;
        /**
         * @ets_rewrite_static provide_ from "@effect-ts/core/Effect"
         */
        provide_<E, A, R0, R>(next: T.Effect<R & R0, E, A>, r: R, __trace?: string | undefined): T.Effect<R0, E, A>;
        /**
         * @ets_rewrite_static provideAll from "@effect-ts/core/Effect"
         * @ets_data_first provideAll_
         */
        provideAll<R>(r: R, __trace?: string | undefined): <E, A>(next: T.Effect<R, E, A>) => T.Effect<unknown, E, A>;
        /**
         * @ets_rewrite_static provideAll_ from "@effect-ts/core/Effect"
         */
        provideAll<R, E, A>(next: T.Effect<R, E, A>, r: R, __trace?: string | undefined): T.Effect<unknown, E, A>;
        /**
         * @ets_rewrite_static provideLayer from "@effect-ts/core/Effect"
         * @ets_data_first provideLayer_
         */
        provideLayer<R, E, A>(layer: Layer<R, E, A>): <E1, A1>(self: T.Effect<A, E1, A1>) => T.Effect<R, E | E1, A1>;
        /**
         * @ets_rewrite_static provideLayer_ from "@effect-ts/core/Effect"
         */
        provideLayer<R, E, A, E1, A1>(self: T.Effect<A, E1, A1>, layer: Layer<R, E, A>): T.Effect<R, E | E1, A1>;
        /**
         * @ets_rewrite_static provideSomeLayer from "@effect-ts/core/Effect"
         * @ets_data_first provideSomeLayer_
         */
        provideSomeLayer<R, E, A>(layer: Layer<R, E, A>): <R1, E1, A1>(self: T.Effect<R1 & A, E1, A1>) => T.Effect<R & R1, E | E1, A1>;
        /**
         * @ets_rewrite_static provideSomeLayer_ from "@effect-ts/core/Effect"
         */
        provideSomeLayer<R1, E1, A1, R, E, A>(self: T.Effect<R1 & A, E1, A1>, layer: Layer<R, E, A>): T.Effect<R & R1, E | E1, A1>;
        /**
         * @ets_rewrite_static provideSome from "@effect-ts/core/Effect"
         * @ets_data_first provideSome_
         */
        provideSome<R0, R>(f: (r0: R0) => R, __trace?: string | undefined): <E, A>(effect: T.Effect<R, E, A>) => T.Effect<R0, E, A>;
        /**
         * @ets_rewrite_static provideSome_ from "@effect-ts/core/Effect"
         */
        provideSome<R0, R, E, A>(effect: T.Effect<R, E, A>, f: (r0: R0) => R, __trace?: string | undefined): T.Effect<R0, E, A>;
        /**
         * @ets_rewrite_static raceAll from "@effect-ts/core/Effect"
         */
        raceAll: typeof T.raceAll;
        /**
         * @ets_rewrite_static raceAllWait from "@effect-ts/core/Effect"
         */
        raceAllWait: typeof T.raceAllWait;
        /**
         * @ets_rewrite_static raceAllWithStrategy from "@effect-ts/core/Effect"
         */
        raceAllWithStrategy: typeof T.raceAllWithStrategy;
        /**
         * @ets_rewrite_static reduce from "@effect-ts/core/Effect"
         * @ets_data_first reduce_
         */
        reduce<Z, R, E, A>(zero: Z, f: (z: Z, a: A) => Effect<R, E, Z>, __trace?: string): (i: Iterable<A>) => Effect<R, E, Z>;
        /**
         * @ets_rewrite_static reduce_ from "@effect-ts/core/Effect"
         */
        reduce<A, Z, R, E>(i: Iterable<A>, zero: Z, f: (z: Z, a: A) => T.Effect<R, E, Z>, __trace?: string | undefined): T.Effect<R, E, Z>;
        /**
         * @ets_rewrite_static reduceAll from "@effect-ts/core/Effect"
         * @ets_data_first reduceAll_
         */
        reduceAll<A>(f: (acc: A, a: A) => A, __trace?: string | undefined): <R, E>(as: NonEmptyArray<T.Effect<R, E, A>>) => T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static reduceAll_ from "@effect-ts/core/Effect"
         */
        reduceAll<R, E, A>(as: NonEmptyArray<T.Effect<R, E, A>>, f: (acc: A, a: A) => A, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static reduceAllPar from "@effect-ts/core/Effect"
         * @ets_data_first reduceAllPar_
         */
        reduceAllPar<A>(f: (acc: A, a: A) => A, __trace?: string | undefined): <R, E>(as: NonEmptyArray<T.Effect<R, E, A>>) => T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static reduceAllPar_ from "@effect-ts/core/Effect"
         */
        reduceAllPar<R, E, A>(as: NonEmptyArray<T.Effect<R, E, A>>, f: (acc: A, a: A) => A, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static reduceAllParN from "@effect-ts/core/Effect"
         * @ets_data_first reduceAllParN_
         */
        reduceAllParN<A>(n: number, f: (acc: A, a: A) => A, __trace?: string): <R, E>(as: NonEmptyArray<Effect<R, E, A>>) => Effect<R, E, A>;
        /**
         * @ets_rewrite_static reduceAllParN_ from "@effect-ts/core/Effect"
         */
        reduceAllParN<R, E, A>(as: NonEmptyArray<T.Effect<R, E, A>>, n: number, f: (acc: A, a: A) => A, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_static reduceRight from "@effect-ts/core/Effect"
         * @ets_data_first reduceRight_
         */
        reduceRight<R, E, A, Z>(zero: Z, f: (a: A, z: Z) => T.Effect<R, E, Z>, __trace?: string | undefined): (i: Iterable<A>) => T.Effect<R, E, Z>;
        /**
         * @ets_rewrite_static reduceRight_ from "@effect-ts/core/Effect"
         */
        reduceRight<A, Z, R, E>(i: Iterable<A>, zero: Z, f: (a: A, z: Z) => T.Effect<R, E, Z>, __trace?: string | undefined): T.Effect<R, E, Z>;
        /**
         * @ets_rewrite_static runtime from "@effect-ts/core/Effect"
         */
        runtime: typeof T.runtime;
        /**
         * @ets_rewrite_static second from "@effect-ts/core/Effect"
         */
        second: typeof T.second;
        /**
         * @ets_rewrite_static sequential from "@effect-ts/core/Effect"
         */
        sequential: typeof T.sequential;
        /**
         * @ets_rewrite_static service from "@effect-ts/core/Effect"
         */
        service: typeof T.service;
        /**
         * @ets_rewrite_static services from "@effect-ts/core/Effect"
         */
        services: typeof T.services;
        /**
         * @ets_rewrite_static sleep from "@effect-ts/core/Effect"
         */
        sleep: typeof T.sleep;
        /**
         * @ets_rewrite_static struct from "@effect-ts/core/Effect"
         */
        struct: typeof T.struct;
        /**
         * @ets_rewrite_static structPar from "@effect-ts/core/Effect"
         */
        structPar: typeof T.structPar;
        /**
         * @ets_rewrite_static structParN from "@effect-ts/core/Effect"
         * @ets_data_first structParN_
         */
        structParN(n: number, __trace?: string): <NER extends Record<string, Effect<any, any, any>>>(r: EnforceNonEmptyRecord<NER> & Record<string, Effect<any, any, any>>) => Effect<_R<NER[keyof NER]>, _E<NER[keyof NER]>, {
            [K in keyof NER]: [NER[K]] extends [Effect<any, any, infer A>] ? A : never;
        }>;
        /**
         * @ets_rewrite_static structParN_ from "@effect-ts/core/Effect"
         */
        structParN<NER extends Record<string, Effect<any, any, any>>>(r: EnforceNonEmptyRecord<NER> & Record<string, Effect<any, any, any>>, n: number, __trace?: string): Effect<_R<NER[keyof NER]>, _E<NER[keyof NER]>, {
            [K in keyof NER]: [NER[K]] extends [Effect<any, any, infer A>] ? A : never;
        }>;
        /**
         * @ets_rewrite_static succeedWith from "@effect-ts/core/Effect"
         */
        succeed: typeof T.succeedWith;
        /**
         * @ets_rewrite_static suspend from "@effect-ts/core/Effect"
         */
        suspend: typeof T.suspend;
        /**
         * @ets_rewrite_static succeed from "@effect-ts/core/Effect"
         */
        succeedNow: typeof T.succeed;
        /**
         * @ets_rewrite_static trace from "@effect-ts/core/Effect"
         */
        trace: typeof T.trace;
        /**
         * @ets_rewrite_static tracedMask from "@effect-ts/core/Effect"
         */
        tracedMask: typeof T.tracedMask;
        /**
         * @ets_rewrite_static transplant from "@effect-ts/core/Effect"
         */
        transplant: typeof T.transplant;
        /**
         * @ets_rewrite_static try from "@effect-ts/core/Effect"
         */
        try: typeof T.try;
        /**
         * @ets_rewrite_static tryCatch from "@effect-ts/core/Effect"
         */
        tryCatch: typeof T.tryCatchOption;
        /**
         * @ets_rewrite_static tryCatch from "@effect-ts/core/Effect"
         */
        tryCatchOption: typeof T.tryCatchOption;
        /**
         * @ets_rewrite_static tryCatchSuspend from "@effect-ts/core/Effect"
         */
        tryCatchSuspend: typeof T.tryCatchSuspend;
        /**
         * @ets_rewrite_static tryCatchPromise from "@effect-ts/core/Effect"
         */
        tryCatchPromise: typeof T.tryCatchPromise;
        /**
         * @ets_rewrite_static tryPromise from "@effect-ts/core/Effect"
         */
        tryPromise: typeof T.tryPromise;
        /**
         * @ets_rewrite_static tuple from "@effect-ts/core/Effect"
         */
        tuple: typeof T.tuple;
        /**
         * @ets_rewrite_static tuplePar from "@effect-ts/core/Effect"
         */
        tuplePar: typeof T.tuplePar;
        /**
         * @ets_rewrite_static tupleParN from "@effect-ts/core/Effect"
         */
        tupleParN: typeof T.tupleParN;
        /**
         * @ets_rewrite_static uninterruptibleMask from "@effect-ts/core/Effect"
         */
        uninterruptibleMask: typeof T.uninterruptibleMask;
        /**
         * @ets_rewrite_static union from "@effect-ts/core/Effect"
         */
        union: typeof T.union;
        /**
         * @ets_rewrite_static unionFn from "@effect-ts/core/Effect"
         */
        unionFn: typeof T.unionFn;
        /**
         * @ets_rewrite_static unit from "@effect-ts/core/Effect"
         */
        unit: typeof T.unit;
        /**
         * @ets_rewrite_static unitTraced from "@effect-ts/core/Effect"
         */
        unitTraced: typeof T.unitTraced;
        /**
         * @ets_rewrite_static untracedMask from "@effect-ts/core/Effect"
         */
        untracedMask: typeof T.untracedMask;
        /**
         * @ets_rewrite_static validate from "@effect-ts/core/Effect"
         * @ets_data_first validate_
         */
        validate<A, R, E, B>(f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, Chunk<E>, Chunk<B>>;
        /**
         * @ets_rewrite_static validate_ from "@effect-ts/core/Effect"
         */
        validate<A, R, E, B>(as: Iterable<A>, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.Effect<R, Chunk<E>, Chunk<B>>;
        /**
         * @ets_rewrite_static validatePar from "@effect-ts/core/Effect"
         * @ets_data_first validatePar_
         */
        validatePar<A, R, E, B>(f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, Chunk<E>, Chunk<B>>;
        /**
         * @ets_rewrite_static validatePar_ from "@effect-ts/core/Effect"
         */
        validatePar<A, R, E, B>(as: Iterable<A>, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.Effect<R, Chunk<E>, Chunk<B>>;
        /**
         * @ets_rewrite_static validateParN from "@effect-ts/core/Effect"
         * @ets_data_first validateParN_
         */
        validateParN<A, R, E, B>(n: number, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): (as: Iterable<A>) => T.Effect<R, Chunk<E>, Chunk<B>>;
        /**
         * @ets_rewrite_static validateParN_ from "@effect-ts/core/Effect"
         */
        validateParN<A, R, E, B>(as: Iterable<A>, n: number, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.Effect<R, Chunk<E>, Chunk<B>>;
        /**
         * @ets_rewrite_static validateExec from "@effect-ts/core/Effect"
         * @ets_data_first validateExec_
         */
        validateExec<R, E, A, B>(es: T.ExecutionStrategy, f: (a: A) => Effect<R, E, B>, __trace?: string): (as: Iterable<A>) => Effect<R, Chunk<E>, Chunk<B>>;
        /**
         * @ets_rewrite_static validateExec_ from "@effect-ts/core/Effect"
         */
        validateExec<A, R, E, B>(as: Iterable<A>, es: T.ExecutionStrategy, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.Effect<R, Chunk<E>, Chunk<B>>;
        /**
         * @ets_rewrite_static validateFirst from "@effect-ts/core/Effect"
         * @ets_data_first validateFirst_
         */
        validateFirst<A, R, E, B>(f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): (i: Iterable<A>) => T.Effect<R, Chunk<E>, B>;
        /**
         * @ets_rewrite_static validateFirst_ from "@effect-ts/core/Effect"
         */
        validateFirst<A, R, E, B>(i: Iterable<A>, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.Effect<R, Chunk<E>, B>;
        /**
         * @ets_rewrite_static validateFirstPar from "@effect-ts/core/Effect"
         * @ets_data_first validateFirstPar_
         */
        validateFirstPar<A, R, E, B>(f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): (i: Iterable<A>) => T.Effect<R, Chunk<E>, B>;
        /**
         * @ets_rewrite_static validateFirstPar_ from "@effect-ts/core/Effect"
         */
        validateFirstPar<A, R, E, B>(i: Iterable<A>, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.Effect<R, Chunk<E>, B>;
        /**
         * @ets_rewrite_static validateFirstParN from "@effect-ts/core/Effect"
         * @ets_data_first validateFirstParN_
         */
        validateFirstParN<A, R, E, B>(n: number, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): (i: Iterable<A>) => T.Effect<R, Chunk<E>, B>;
        /**
         * @ets_rewrite_static validateFirstParN_ from "@effect-ts/core/Effect"
         */
        validateFirstParN<A, R, E, B>(i: Iterable<A>, n: number, f: (a: A) => T.Effect<R, E, B>, __trace?: string | undefined): T.Effect<R, Chunk<E>, B>;
        /**
         * @ets_rewrite_static whenCase from "@effect-ts/core/Effect"
         * @ets_data_first whenCase_
         */
        whenCase<R, E, A, X>(pf: (a: A) => O.Option<T.Effect<R, E, X>>, __trace?: string | undefined): (a: A) => T.Effect<R, E, void>;
        /**
         * @ets_rewrite_static whenCase_ from "@effect-ts/core/Effect"
         */
        whenCase<R, E, A, X>(a: A, pf: (a: A) => O.Option<T.Effect<R, E, X>>, __trace?: string | undefined): T.Effect<R, E, void>;
        /**
         * @ets_rewrite_static withChildren from "@effect-ts/core/Effect"
         */
        withChildren: typeof T.withChildren;
        /**
         * @ets_rewrite_static withRuntime from "@effect-ts/core/Effect"
         */
        withRuntime: typeof T.withRuntime;
        /**
         * @ets_rewrite_static withRuntime from "@effect-ts/core/Effect"
         */
        withRuntimeM: typeof T.withRuntimeM;
        /**
         * @ets_rewrite_static yieldNow from "@effect-ts/core/Effect"
         */
        yieldNow: typeof T.yieldNow;
    }
    interface Base<R, E, A> extends Effect<R, E, A> {
    }
    interface Effect<R, E, A> extends EffectOps {
    }
    interface EffectOps {
        /**
         * @ets_rewrite_method pipe from "smart:pipe"
         */
        pipe<Self, Ret>(this: Self, f: (self: Self) => Ret): Ret;
        /**
         * @ets_rewrite_method absolve from "@effect-ts/core/Effect"
         */
        absolve<RX, EX, EE, AA>(this: T.Effect<RX, EX, E.Either<EE, AA>>, __trace?: string): T.Effect<RX, EX | EE, AA>;
        /**
         * @ets_rewrite_method absorb from "@effect-ts/core/Effect"
         */
        absorb<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, unknown, A>;
        /**
         * @ets_rewrite_method absorbWith_ from "@effect-ts/core/Effect"
         */
        absorbWith<R, A, E>(this: T.Effect<R, E, A>, f: (e: E) => unknown, __trace?: string | undefined): T.Effect<R, unknown, A>;
        /**
         * @ets_rewrite_method andThen_ from "@effect-ts/core/Effect"
         */
        andThen<R, E, A, E1, A1>(this: Effect<R, E, A>, fb: Effect<A, E1, A1>, __trace?: string): Effect<R, E | E1, A1>;
        /**
         * @ets_rewrite_method ap_ from "@effect-ts/core/Effect"
         */
        ap<R, E, B, R2, E2, A>(this: T.Effect<R, E, (a: A) => B>, fa: T.Effect<R2, E2, A>, __trace?: string | undefined): T.Effect<R & R2, E | E2, B>;
        /**
         * @ets_rewrite_method asService_ from "@effect-ts/core/Effect"
         */
        asService<R, E, A>(this: T.Effect<R, E, A>, has: Tag<A>, __trace?: string | undefined): T.Effect<R, E, Has<A>>;
        /**
         * @ets_rewrite_method as_ from "@effect-ts/core/Effect"
         */
        as<RX, EX, AX, B>(this: T.Effect<RX, EX, AX>, b: B, __trace?: string): T.Effect<RX, EX, B>;
        /**
         * @ets_rewrite_method asSome from "@effect-ts/core/Effect"
         */
        asSome<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, O.Option<A>>;
        /**
         * @ets_rewrite_method asSomeError from "@effect-ts/core/Effect"
         */
        asSomeError<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, O.Option<E>, A>;
        /**
         * @ets_rewrite_method asUnit from "@effect-ts/core/Effect"
         */
        asUnit<R, E, X>(this: T.Effect<R, E, X>, __trace?: string | undefined): T.Effect<R, E, void>;
        /**
         * @ets_rewrite_method awaitAllChildren from "@effect-ts/core/Effect"
         */
        awaitAllChildren<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method bimap_ from "@effect-ts/core/Effect"
         */
        bimap<R, E, A, E2, B>(this: T.Effect<R, E, A>, f: (e: E) => E2, g: (a: A) => B, __trace?: string | undefined): T.Effect<R, E2, B>;
        /**
         * @ets_rewrite_method bind_ from "@effect-ts/core/Effect"
         */
        bind<RX, EX, AX extends Record<string, unknown>, N extends string, R2, E2, B>(this: T.Effect<RX, EX, AX>, n: N & N extends keyof AX ? [`${N} already in use`] : N, f: (a: AX) => T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, Compute<AX & {
            readonly [k in N]: B;
        }, "flat">>;
        /**
         * @ets_rewrite_method bindAll_ from "@effect-ts/core/Effect"
         */
        bindAll<K, NER extends Record<string, Effect<any, any, any>> & {
            [k in keyof K & keyof NER]?: never;
        }, R, E>(this: Effect<R, E, K>, r: (k: K) => EnforceNonEmptyRecord<NER> & Record<string, Effect<any, any, any>>, __trace?: string): Effect<R & _R<NER[keyof NER]>, E | _E<NER[keyof NER]>, Compute<K & {
            readonly [K in keyof NER]: [NER[K]] extends [Effect<any, any, infer A>] ? A : never;
        }, "flat">>;
        /**
         * @ets_rewrite_method bindAllPar_ from "@effect-ts/core/Effect"
         */
        bindAllPar<K, NER extends Record<string, Effect<any, any, any>> & {
            [k in keyof K & keyof NER]?: never;
        }, R, E>(this: Effect<R, E, K>, r: (k: K) => EnforceNonEmptyRecord<NER> & Record<string, Effect<any, any, any>>, __trace?: string): Effect<R & _R<NER[keyof NER]>, E | _E<NER[keyof NER]>, Compute<K & {
            readonly [K in keyof NER]: [NER[K]] extends [Effect<any, any, infer A>] ? A : never;
        }, "flat">>;
        /**
         * @ets_rewrite_method bindAllParN_ from "@effect-ts/core/Effect"
         */
        bindAllParN<K, NER extends Record<string, Effect<any, any, any>> & {
            [k in keyof K & keyof NER]?: never;
        }, R, E>(this: Effect<R, E, K>, n: number, r: (k: K) => EnforceNonEmptyRecord<NER> & Record<string, Effect<any, any, any>>, __trace?: string): Effect<R & _R<NER[keyof NER]>, E | _E<NER[keyof NER]>, Compute<K & {
            readonly [K in keyof NER]: [NER[K]] extends [Effect<any, any, infer A>] ? A : never;
        }, "flat">>;
        /**
         * @ets_rewrite_method bracketExit_ from "@effect-ts/core/Effect"
         */
        bracket<RX, EX, AX, R2, E2, A2, R3, B>(this: T.Effect<RX, EX, AX>, use: (a: AX) => Effect<R2, E2, A2>, release: (a: AX, exit: Exit<E2, A2>) => Effect<R3, never, B>, __trace?: string): T.Effect<RX & R2 & R3, EX | E2, A2>;
        /**
         * @ets_rewrite_method bracketFiber_ from "@effect-ts/core/Effect"
         */
        bracketFiber<R, E, A, R2, E2, A2>(this: Effect<R, E, A>, use: (f: Fiber.Runtime<E, A>) => Effect<R2, E2, A2>, __trace?: string): Effect<R & R2, E2, Exit<E, A>>;
        /**
         * @ets_rewrite_method bracketOnError_ from "@effect-ts/core/Effect"
         */
        bracketOnError<R, E, A, E1, R1, A1, R2, E2, X>(this: Effect<R, E, A>, use: (a: A) => Effect<R1, E1, A1>, release: (a: A, e: Exit<E1, A1>) => Effect<R2, E2, X>, __trace?: string): Effect<R & R1 & R2, E | E1 | E2, A1>;
        /**
         * @ets_rewrite_method cached_ from "@effect-ts/core/Effect"
         */
        cached<R, E, A>(this: T.Effect<R, E, A>, ttl: number, __trace?: string | undefined): T.RIO<R & Has<Clock>, T.IO<E, A>>;
        /**
         * @ets_rewrite_method cachedInvalidate_ from "@effect-ts/core/Effect"
         */
        cachedInvalidate<R, E, A>(this: T.Effect<R, E, A>, ttl: number, __trace?: string | undefined): T.RIO<R & Has<Clock>, Tp.Tuple<[T.IO<E, A>, T.UIO<void>]>>;
        /**
         * @ets_rewrite_method catchAll_ from "@effect-ts/core/Effect"
         */
        catchAll<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: (e: EX) => T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, E2, AX | B>;
        /**
         * @ets_rewrite_method catchTag_ from "@effect-ts/core/Effect"
         */
        catchTag<RX, EX, AX, Tag extends (EX extends {
            _tag: infer X;
        } ? X : never) & string, R2, E2, B>(this: T.Effect<RX, EX, AX>, tag: Tag, f: (e: Extract<EX, {
            readonly _tag: Tag;
        }>) => T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, E2 | Exclude<EX, {
            readonly _tag: Tag;
        }>, AX | B>;
        /**
         * @ets_rewrite_method catchAllCause_ from "@effect-ts/core/Effect"
         */
        catchAllCause<R2, E2, A2, R, E, A>(this: T.Effect<R2, E2, A2>, f: (_: Cause<E2>) => T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R2 & R, E, A2 | A>;
        /**
         * @ets_rewrite_method catchAllDefect_ from "@effect-ts/core/Effect"
         */
        catchAllDefect<R2, E2, A2, R, E, A>(this: T.Effect<R2, E2, A2>, f: (_: unknown) => T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R2 & R, E2 | E, A2 | A>;
        /**
         * @ets_rewrite_method catchSome_ from "@effect-ts/core/Effect"
         */
        catchSome<R, E, A, R2, E2, A2>(this: T.Effect<R, E, A>, f: (e: E) => O.Option<T.Effect<R2, E2, A2>>, __trace?: string | undefined): T.Effect<R & R2, E | E2, A | A2>;
        /**
         * @ets_rewrite_method catchSomeCause_ from "@effect-ts/core/Effect"
         */
        catchSomeCause<R2, E2, A2, R, E, A>(this: T.Effect<R2, E2, A2>, f: (_: Cause<E2>) => O.Option<T.Effect<R, E, A>>, __trace?: string | undefined): T.Effect<R2 & R, E2 | E, A2 | A>;
        /**
         * @ets_rewrite_method catchSomeDefect_ from "@effect-ts/core/Effect"
         */
        catchSomeDefect<R2, E2, A2, R, E, A>(this: T.Effect<R2, E2, A2>, f: (_: unknown) => O.Option<T.Effect<R, E, A>>, __trace?: string | undefined): T.Effect<R2 & R, E2 | E, A2 | A>;
        /**
         * @ets_rewrite_method cause from "@effect-ts/core/Effect"
         */
        cause<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.RIO<R, Cause<E>>;
        /**
         * @ets_rewrite_method chain_ from "@effect-ts/core/Effect"
         */
        chain<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: (a: AX) => T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, B>;
        /**
         * @ets_rewrite_method chainError_ from "@effect-ts/core/Effect"
         */
        chainError<R, E, A, R2, E2>(this: T.Effect<R, E, A>, f: (e: E) => T.RIO<R2, E2>, __trace?: string | undefined): T.Effect<R & R2, E2, A>;
        /**
         * @ets_rewrite_method compose_ from "@effect-ts/core/Effect"
         */
        compose<A, E1, B, R, E>(this: T.Effect<R, E, A>, that: T.Effect<A, E1, B>, __trace?: string | undefined): T.Effect<R, E1 | E, B>;
        /**
         * @ets_rewrite_method continueOrFail_ from "@effect-ts/core/Effect"
         */
        continueOrFail<R, E, E1, A, A2>(this: Effect<R, E, A>, f: () => E1, pf: (a: A) => O.Option<A2>, __trace?: string): Effect<R, E | E1, A2>;
        /**
         * @ets_rewrite_method continueOrFailM_ from "@effect-ts/core/Effect"
         */
        continueOrFailM<R, E, E1, A, R2, E2, A2>(this: Effect<R, E, A>, f: () => E1, pf: (a: A) => O.Option<Effect<R2, E2, A2>>, __trace?: string): Effect<R & R2, E | E1 | E2, A2>;
        /**
         * @ets_rewrite_method delay_ from "@effect-ts/core/Effect"
         */
        delay<R, E, A>(this: T.Effect<R, E, A>, ms: number, __trace?: string | undefined): T.Effect<R & Has<Clock>, E, A>;
        /**
         * @ets_rewrite_method either from "@effect-ts/core/Effect"
         */
        either<RX, EX, AX>(this: T.Effect<RX, EX, AX>, __trace?: string): T.Effect<RX, never, E.Either<EX, AX>>;
        /**
         * @ets_rewrite_method ensuring_ from "@effect-ts/core/Effect"
         */
        ensuring<RX, EX, AX, R1, X>(this: T.Effect<RX, EX, AX>, finalizer: Effect<R1, never, X>, __trace?: string): T.Effect<RX & R1, EX, AX>;
        /**
         * @ets_rewrite_method ensuringChild_ from "@effect-ts/core/Effect"
         */
        ensuringChild<R, E, A, R2, X>(this: T.Effect<R, E, A>, f: (_: Fiber.Fiber<any, Chunk<unknown>>) => T.RIO<R2, X>, __trace?: string | undefined): T.Effect<R & R2, E, A>;
        /**
         * @ets_rewrite_method ensuringChildren_ from "@effect-ts/core/Effect"
         */
        ensuringChildren<R, E, A, R1, X>(this: T.Effect<R, E, A>, children: (_: SortedSet<Fiber.Runtime<any, any>>) => T.RIO<R1, X>, __trace?: string | undefined): T.Effect<R & R1, E, A>;
        /**
         * @ets_rewrite_method eventually from "@effect-ts/core/Effect"
         */
        eventually<R, E, A>(fa: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, never, A>;
        /**
         * @ets_rewrite_method flatten from "@effect-ts/core/Effect"
         */
        flatten<R, E, R1, E1, A>(this: T.Effect<R, E, T.Effect<R1, E1, A>>, __trace?: string | undefined): T.Effect<R & R1, E | E1, A>;
        /**
         * @ets_rewrite_method flattenErrorOption_ from "@effect-ts/core/Effect"
         */
        flattenErrorOption<R, E, A, E2>(this: T.Effect<R, O.Option<E>, A>, def: () => E2, __trace?: string | undefined): T.Effect<R, E | E2, A>;
        /**
         * @ets_rewrite_method flip from "@effect-ts/core/Effect"
         */
        flip<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, A, E>;
        /**
         * @ets_rewrite_method flipWith_ from "@effect-ts/core/Effect"
         */
        flipWith<R, E, A, R2, E2, A2>(this: T.Effect<R, E, A>, f: (self: T.Effect<R, A, E>) => T.Effect<R2, A2, E2>, __trace?: string | undefined): T.Effect<R2, E2, A2>;
        /**
         * @ets_rewrite_method foldCauseM_ from "@effect-ts/core/Effect"
         */
        foldCauseM<RX, EX, AX, R2, E2, A2, R3, E3, A3>(this: T.Effect<RX, EX, AX>, g: (e: Cause<EX>) => T.Effect<R3, E3, A3>, f: (a: AX) => T.Effect<R2, E2, A2>, __trace?: string): T.Effect<RX & R2 & R3, E2 | E3, A2 | A3>;
        /**
         * @ets_rewrite_method foldM_ from "@effect-ts/core/Effect"
         */
        foldM<RX, EX, AX, R2, E2, A2, R3, E3, A3>(this: T.Effect<RX, EX, AX>, g: (e: EX) => T.Effect<R3, E3, A3>, f: (a: AX) => T.Effect<R2, E2, A2>, __trace?: string): T.Effect<RX & R2 & R3, E2 | E3, A2 | A3>;
        /**
         * @ets_rewrite_method forever from "@effect-ts/core/Effect"
         */
        forever<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, never>;
        /**
         * @ets_rewrite_method fork from "@effect-ts/core/Effect"
         */
        fork<RX, EX, AX>(this: T.Effect<RX, EX, AX>, __trace?: string): T.Effect<RX, never, Fiber.FiberContext<EX, AX>>;
        /**
         * @ets_rewrite_method forkAs_ from "@effect-ts/core/Effect"
         */
        forkAs<R, E, A>(this: T.Effect<R, E, A>, name: string, __trace?: string | undefined): T.RIO<R, Fiber.FiberContext<E, A>>;
        /**
         * @ets_rewrite_method forkManaged from "@effect-ts/core/Effect"
         */
        forkManaged<RX, EX, AX>(this: T.Effect<RX, EX, AX>, __trace?: string): M.Managed<RX, never, Fiber.Fiber<EX, AX>>;
        /**
         * @ets_rewrite_method forkDaemon from "@effect-ts/core/Effect"
         */
        forkDaemon<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.RIO<R, Fiber.FiberContext<E, A>>;
        /**
         * @ets_rewrite_method forkDaemonReport_ from "@effect-ts/core/Effect"
         */
        forkDaemonReport<R, E, A>(this: T.Effect<R, E, A>, reportFailure: T.FailureReporter, __trace?: string | undefined): T.RIO<R, Fiber.FiberContext<E, A>>;
        /**
         * @ets_rewrite_method forkIn_ from "@effect-ts/core/Effect"
         */
        forkIn<R, E, A>(this: T.Effect<R, E, A>, scope: Scope<Exit<any, any>>, __trace?: string | undefined): T.RIO<R, Fiber.Runtime<E, A>>;
        /**
         * @ets_rewrite_method forkInReport_ from "@effect-ts/core/Effect"
         */
        forkInReport<R, E, A>(this: T.Effect<R, E, A>, scope: Scope<Exit<any, any>>, reportFailure: T.FailureReporter, __trace?: string | undefined): T.RIO<R, Fiber.Runtime<E, A>>;
        /**
         * @ets_rewrite_method forkWithErrorHandler_ from "@effect-ts/core/Effect"
         */
        forkWithErrorHandler<R, R2, E, A>(self: T.Effect<R, E, A>, handler: (e: E) => T.RIO<R2, void>, __trace?: string | undefined): T.RIO<R & R2, Fiber.FiberContext<E, A>>;
        /**
         * @ets_rewrite_method get from "@effect-ts/core/Effect"
         */
        get<R, E, A>(this: T.Effect<R, E, O.Option<A>>, __trace?: string | undefined): T.Effect<R, O.Option<E>, A>;
        /**
         * @ets_rewrite_method ifM_ from "@effect-ts/core/Effect"
         */
        ifM<R, E, R1, E1, A1, R2, E2, A2>(this: Effect<R, E, boolean>, onTrue: () => Effect<R1, E1, A1>, onFalse: () => Effect<R2, E2, A2>, __trace?: string): Effect<R & R1 & R2, E | E1 | E2, A1 | A2>;
        /**
         * @ets_rewrite_method provideAll_ from "@effect-ts/core/Effect"
         */
        injectAll<RX, EX, AX>(this: T.Effect<RX, EX, AX>, env: AX): T.Effect<unknown, EX, AX>;
        /**
         * @ets_rewrite_method provideAll_ from "@effect-ts/core/Effect"
         */
        injectEnv<RX, EX, AX, AX2>(this: T.Effect<RX, EX, AX>, env: AX2): T.Effect<RX extends Has<AX2> & infer K ? K : unknown, EX, AX>;
        /**
         * @ets_rewrite_method provideSome_ from "@effect-ts/core/Effect"
         */
        injectSome<RX, EX, AX, R2>(this: T.Effect<RX, EX, AX>, env: (_: R2) => AX): T.Effect<R2, EX, AX>;
        /**
         * @ets_rewrite_method provideService_ from "@effect-ts/core/Effect"
         */
        injectService<RX, EX, AX, A2>(this: T.Effect<RX, EX, AX>, tag: Tag<A2>, value: A2): T.Effect<RX extends Has<A2> & infer K ? K : unknown, EX, AX>;
        /**
         * @ets_rewrite_method provideServiceM_ from "@effect-ts/core/Effect"
         */
        injectServiceM<RX, EX, AX, R2, E2, A2>(this: T.Effect<RX, EX, AX>, tag: Tag<A2>, value: T.Effect<R2, E2, A2>): T.Effect<R2 & (RX extends Has<A2> & infer K ? K : unknown), EX | E2, AX>;
        /**
         * @ets_rewrite_method provideSomeLayer_ from "@effect-ts/core/Effect"
         */
        inject<RX, EX, AX, R2, E2, A2>(this: T.Effect<RX, EX, AX>, layer: Layer<R2, E2, A2>): T.Effect<Erase<RX, A2> & R2, EX | E2, AX>;
        /**
         * @ets_rewrite_method ignore from "@effect-ts/core/Effect"
         */
        ignore<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.RIO<R, void>;
        /**
         * @ets_rewrite_method in_ from "@effect-ts/core/Effect"
         */
        in<R, E, A>(this: T.Effect<R, E, A>, scope: Scope<any>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method interruptAllChildren from "@effect-ts/core/Effect"
         */
        interruptAllChildren<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method interruptStatus_ from "@effect-ts/core/Effect"
         */
        interruptStatus<R, E, A>(this: T.Effect<R, E, A>, flag: Fiber.InterruptStatus, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method interruptible from "@effect-ts/core/Effect"
         */
        interruptible<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method isFailure from "@effect-ts/core/Effect"
         */
        isFailure<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, never, boolean>;
        /**
         * @ets_rewrite_method isSuccess from "@effect-ts/core/Effect"
         */
        isSuccess<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, never, boolean>;
        /**
         * @ets_rewrite_method join_ from "@effect-ts/core/Effect"
         */
        join<R, E, A, R1, E1, A1>(this: T.Effect<R, E, A>, that: T.Effect<R1, E1, A1>, __trace?: string | undefined): T.Effect<E.Either<R, R1>, E | E1, A | A1>;
        /**
         * @ets_rewrite_method joinEither_ from "@effect-ts/core/Effect"
         */
        joinEither<R, E, A, R1, E1, A1>(this: T.Effect<R, E, A>, that: T.Effect<R1, E1, A1>, __trace?: string | undefined): T.Effect<E.Either<R, R1>, E | E1, E.Either<A, A1>>;
        /**
         * @ets_rewrite_method left from "@effect-ts/core/Effect"
         */
        left<R, E, B, C>(self: T.Effect<R, E, E.Either<B, C>>): T.Effect<R, O.Option<E>, B>;
        /**
         * @ets_rewrite_method leftOrFail_ from "@effect-ts/core/Effect"
         */
        leftOrFail<R, E, B, C, E1>(this: T.Effect<R, E, E.Either<B, C>>, orFail: (c: C) => E1, __trace?: string | undefined): T.Effect<R, E | E1, B>;
        /**
         * @ets_rewrite_method leftOrFailException from "@effect-ts/core/Effect"
         */
        leftOrFailException<R, E, B, C>(this: T.Effect<R, E, E.Either<B, C>>, __trace?: string | undefined): T.Effect<R, E | NoSuchElementException, B>;
        /**
         * @ets_rewrite_method let_ from "@effect-ts/core/Effect"
         */
        let<RX, EX, AX extends Record<string, unknown>, N extends string, B>(this: T.Effect<RX, EX, AX>, n: N & N extends keyof AX ? [`${N} already in use`] : N, f: (a: AX) => B, __trace?: string): T.Effect<RX, EX, Compute<AX & {
            readonly [k in N]: B;
        }, "flat">>;
        /**
         * @ets_rewrite_method map_ from "@effect-ts/core/Effect"
         */
        map<RX, EX, AX, B>(this: T.Effect<RX, EX, AX>, f: (a: AX) => B, __trace?: string): T.Effect<RX, EX, B>;
        /**
         * @ets_rewrite_method mapErrorCause_ from "@effect-ts/core/Effect"
         */
        mapErrorCause<R, E, A, E2>(this: T.Effect<R, E, A>, f: (cause: Cause<E>) => Cause<E2>, __trace?: string | undefined): T.Effect<R, E2, A>;
        /**
         * @ets_rewrite_method mapError_ from "@effect-ts/core/Effect"
         */
        mapError<R, E, E2, A>(this: T.Effect<R, E, A>, f: (e: E) => E2, __trace?: string | undefined): T.Effect<R, E2, A>;
        /**
         * @ets_rewrite_method mapN_ from "@effect-ts/core/Effect"
         */
        mapN<T extends NonEmptyArray<Effect<any, any, any>>, B>(f: (..._: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): (t: Tp.Tuple<T>) => Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_method mapNPar_ from "@effect-ts/core/Effect"
         */
        mapNPar<T extends NonEmptyArray<Effect<any, any, any>>, B>(f: (...args: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): (t: Tp.Tuple<T>) => Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_method mapNParN_ from "@effect-ts/core/Effect"
         */
        mapNParN<T extends NonEmptyArray<Effect<any, any, any>>, B>(n: number, f: (...args: ForcedArray<{
            [k in keyof T]: _A<T[k]>;
        }>) => B, __trace?: string): (t: Tp.Tuple<T>) => Effect<_R<T[number]>, _E<T[number]>, B>;
        /**
         * @ets_rewrite_method mapTryCatch_ from "@effect-ts/core/Effect"
         */
        mapTryCatch<R, E1, E, A, B>(this: T.Effect<R, E1, A>, f: (a: A) => B, onThrow: (u: unknown) => E, __trace?: string | undefined): T.Effect<R, E1 | E, B>;
        /**
         * @ets_rewrite_method merge from "@effect-ts/core/Effect"
         */
        merge<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, never, E | A>;
        /**
         * @ets_rewrite_method onError_ from "@effect-ts/core/Effect"
         */
        onError<R, E, A, R2, E2, X>(this: T.Effect<R, E, A>, cleanup: (exit: Cause<E>) => T.Effect<R2, E2, X>, __trace?: string | undefined): T.Effect<R & R2, E | E2, A>;
        /**
         * @ets_rewrite_method onExit_ from "@effect-ts/core/Effect"
         */
        onExit<R, E, A, R2, E2, X>(this: T.Effect<R, E, A>, cleanup: (exit: Exit<E, A>) => T.Effect<R2, E2, X>, __trace?: string | undefined): T.Effect<R & R2, E | E2, A>;
        /**
         * @ets_rewrite_method onFirst from "@effect-ts/core/Effect"
         */
        onFirst<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, Tp.Tuple<[A, R]>>;
        /**
         * @ets_rewrite_method onInterrupt_ from "@effect-ts/core/Effect"
         */
        onInterrupt<R, E, A, R2, X>(self: T.Effect<R, E, A>, cleanup: (interruptors: readonly Fiber.FiberID[]) => T.Effect<R2, never, X>, __trace?: string | undefined): T.Effect<R & R2, E, A>;
        /**
         * @ets_rewrite_method onSecond from "@effect-ts/core/Effect"
         */
        onSecond<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, Tp.Tuple<[R, A]>>;
        /**
         * @ets_rewrite_method onTermination_ from "@effect-ts/core/Effect"
         */
        onTermination<R1, R, E, A, X>(this: T.Effect<R, E, A>, cleanup: (_: Cause<never>) => T.RIO<R1, X>, __trace?: string | undefined): T.Effect<R & R1, E, A>;
        /**
         * @ets_rewrite_method once from "@effect-ts/core/Effect"
         */
        once<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.UIO<T.Effect<R, E, void>>;
        /**
         * @ets_rewrite_method onlyDefaultEnv from "smart:identity"
         */
        onlyDefaultEnv<E, A>(self: T.Effect<T.DefaultEnv, E, A>): T.Effect<T.DefaultEnv, E, A>;
        /**
         * @ets_rewrite_method option from "@effect-ts/core/Effect"
         */
        option<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.RIO<R, O.Option<A>>;
        /**
         * @ets_rewrite_method optional from "@effect-ts/core/Effect"
         */
        optional<R, E, A>(this: T.Effect<R, O.Option<E>, A>, __trace?: string | undefined): T.Effect<R, E, O.Option<A>>;
        /**
         * @ets_rewrite_method orDie from "@effect-ts/core/Effect"
         */
        orDie<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, never, A>;
        /**
         * @ets_rewrite_method orDieKeep from "@effect-ts/core/Effect"
         */
        orDieKeep<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, never, A>;
        /**
         * @ets_rewrite_method orDieWith_ from "@effect-ts/core/Effect"
         */
        orDieWith<R, E, A>(this: T.Effect<R, E, A>, f: (e: E) => unknown, __trace?: string | undefined): T.Effect<R, never, A>;
        /**
         * @ets_rewrite_method orElseEither_ from "@effect-ts/core/Effect"
         */
        orElseEither<R, E, A, R2, E2, A2>(this: T.Effect<R, E, A>, that: () => T.Effect<R2, E2, A2>, __trace?: string | undefined): T.Effect<R & R2, E2, E.Either<A, A2>>;
        /**
         * @ets_rewrite_method orElseFail_ from "@effect-ts/core/Effect"
         */
        orElseFail<R, E, A, E2>(this: T.Effect<R, E, A>, e: E2, __trace?: string | undefined): T.Effect<R, E2, A>;
        /**
         * @ets_rewrite_method orElseOptional_ from "@effect-ts/core/Effect"
         */
        orElseOptional<R, E, A, R2, E2, A2>(this: T.Effect<R, O.Option<E>, A>, that: () => T.Effect<R2, O.Option<E2>, A2>, __trace?: string | undefined): T.Effect<R & R2, O.Option<E | E2>, A | A2>;
        /**
         * @ets_rewrite_method orElseSucceed_ from "@effect-ts/core/Effect"
         */
        orElseSucceed<R, E, A, A2>(this: T.Effect<R, E, A>, a: A2, __trace?: string | undefined): T.Effect<R, E, A | A2>;
        /**
         * @ets_rewrite_method orElse_ from "@effect-ts/core/Effect"
         */
        orElse<R, E, A, R2, E2, A2>(this: T.Effect<R, E, A>, that: () => T.Effect<R2, E2, A2>, __trace?: string | undefined): T.Effect<R & R2, E2, A | A2>;
        /**
         * @ets_rewrite_method overrideForkScope_ from "@effect-ts/core/Effect"
         */
        overrideForkScope<R, E, A>(this: T.Effect<R, E, A>, scope: Scope<Exit<any, any>>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method race_ from "@effect-ts/core/Effect"
         */
        race<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, AX | B>;
        /**
         * @ets_rewrite_method raceEither_ from "@effect-ts/core/Effect"
         */
        raceEither<R, E, A, R2, E2, A2>(this: T.Effect<R, E, A>, that: T.Effect<R2, E2, A2>, __trace?: string | undefined): T.Effect<R & R2, E | E2, E.Either<A, A2>>;
        /**
         * @ets_rewrite_method raceFirst_ from "@effect-ts/core/Effect"
         */
        raceFirst<R, R2, E, E2, A, A2>(this: T.Effect<R, E, A>, that: T.Effect<R2, E2, A2>, __trace?: string | undefined): T.Effect<R & R2, E | E2, A | A2>;
        /**
         * @ets_rewrite_method raceWith_ from "@effect-ts/core/Effect"
         */
        raceWith<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(this: Effect<R, E, A>, right: Effect<R1, E1, A1>, leftWins: (exit: Exit<E, A>, fiber: Fiber.Fiber<E1, A1>) => Effect<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber.Fiber<E, A>) => Effect<R3, E3, A3>, __trace?: string): Effect<R & R1 & R2 & R3, E2 | E3, A2 | A3>;
        /**
         * @ets_rewrite_method raceWithScope_ from "@effect-ts/core/Effect"
         */
        raceWithScope<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(this: Effect<R, E, A>, right: Effect<R1, E1, A1>, leftWins: (exit: Exit<E, A>, fiber: Fiber.Fiber<E1, A1>) => Effect<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber.Fiber<E, A>) => Effect<R3, E3, A3>, scope: Scope<Exit<any, any>>, __trace?: string): Effect<R & R1 & R2 & R3, E2 | E3, A2 | A3>;
        /**
         * @ets_rewrite_method refailWithTrace from "@effect-ts/core/Effect"
         */
        refailWithTrace<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method refineOrDie_ from "@effect-ts/core/Effect"
         */
        refineOrDie<R, A, E, E1>(this: T.Effect<R, E, A>, pf: (e: E) => O.Option<E1>, __trace?: string | undefined): T.Effect<R, E1, A>;
        /**
         * @ets_rewrite_method refineOrDieWith_ from "@effect-ts/core/Effect"
         */
        refineOrDieWith<R, A, E, E1>(this: T.Effect<R, E, A>, pf: (e: E) => O.Option<E1>, f: (e: E) => unknown, __trace?: string | undefined): T.Effect<R, E1, A>;
        /**
         * @ets_rewrite_method reject_ from "@effect-ts/core/Effect"
         */
        reject<R, E, A, E1>(this: T.Effect<R, E, A>, pf: (a: A) => O.Option<E1>, __trace?: string | undefined): T.Effect<R, E | E1, A>;
        /**
         * @ets_rewrite_method repeat_ from "@effect-ts/core/Effect"
         */
        repeat<R, E, A, SR, B>(this: T.Effect<R, E, A>, schedule: Schedule<SR, A, B>, __trace?: string | undefined): T.Effect<R & SR & Has<Clock>, E, B>;
        /**
         * @ets_rewrite_method repeatN_ from "@effect-ts/core/Effect"
         */
        repeatN<R, E, A>(this: T.Effect<R, E, A>, n: number, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method repeatOrElse_ from "@effect-ts/core/Effect"
         */
        repeatOrElse<R, E, A, SR, B, R2, E2, C>(this: Effect<R, E, A>, schedule: Schedule<SR, A, B>, orElse: (_: E, __: O.Option<B>) => Effect<R2, E2, C>, __trace?: string): Effect<R & SR & R2 & HasClock, E2, C | B>;
        /**
         * @ets_rewrite_method repeatOrElseEither_ from "@effect-ts/core/Effect"
         */
        repeatOrElseEither<R, E, Env1, A, B, R2, E2, C>(this: Effect<R, E, A>, schedule: Schedule<Env1, A, B>, orElse: (_: E, __: O.Option<B>) => Effect<R2, E2, C>, __trace?: string): Effect<R & Env1 & R2 & HasClock, E2, E.Either<C, B>>;
        /**
         * @ets_rewrite_method repeatUntilM_ from "@effect-ts/core/Effect"
         */
        repeatUntilM<R, E, A, R1, E1>(this: T.Effect<R, E, A>, f: (a: A) => T.Effect<R1, E1, boolean>, __trace?: string | undefined): T.Effect<R & R1, E | E1, A>;
        /**
         * @ets_rewrite_method repeatUntil_ from "@effect-ts/core/Effect"
         */
        repeatUntil<R, E, A>(this: T.Effect<R, E, A>, f: (a: A) => boolean, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method repeatWhileM_ from "@effect-ts/core/Effect"
         */
        repeatWhileM<R, E, A, R1, E1>(this: T.Effect<R, E, A>, f: (a: A) => T.Effect<R1, E1, boolean>, __trace?: string | undefined): T.Effect<R & R1, E | E1, A>;
        /**
         * @ets_rewrite_method repeatWhile_ from "@effect-ts/core/Effect"
         */
        repeatWhile<R, E, A>(this: T.Effect<R, E, A>, f: (a: A) => boolean, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method replaceService_ from "@effect-ts/core/Effect"
         */
        replaceService<R1, E1, A1, T>(ma: T.Effect<R1 & Has<T>, E1, A1>, tag: Tag<T>, f: (_: T) => T, __trace?: string | undefined): T.Effect<R1 & Has<T>, E1, A1>;
        /**
         * @ets_rewrite_method replaceServiceM_ from "@effect-ts/core/Effect"
         */
        replaceServiceM<R, E, T, R1, E1, A1>(this: Effect<R1 & Has<T>, E1, A1>, tag: Tag<T>, f: (_: T) => Effect<R, E, T>, __trace?: string): Effect<R & R1 & Has<T>, E | E1, A1>;
        /**
         * @ets_rewrite_method replicate_ from "@effect-ts/core/Effect"
         */
        replicate<R, E, A>(this: T.Effect<R, E, A>, n: number): readonly T.Effect<R, E, A>[];
        /**
         * @ets_rewrite_method require_ from "@effect-ts/core/Effect"
         */
        require<R, A, E, E2>(this: T.Effect<R, E, O.Option<A>>, error: () => E2, __trace?: string | undefined): T.Effect<R, E | E2, A>;
        /**
         * @ets_rewrite_method reserve_ from "@effect-ts/core/Effect"
         */
        reserve<R, E, R2, E2, R3, E3, B, A>(this: Effect<R, E, M.Reservation<R2, E2, A>>, use: (a: A) => Effect<R3, E3, B>, __trace?: string): Effect<R & R2 & R3, E | E2 | E3, B>;
        /**
         * @ets_rewrite_method resetForkScope_ from "@effect-ts/core/Effect"
         */
        resetForkScope<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method result from "@effect-ts/core/Effect"
         */
        result<RX, EX, AX>(this: T.Effect<RX, EX, AX>, __trace?: string): T.Effect<RX, never, Exit<EX, AX>>;
        /**
         * @ets_rewrite_method resurrect from "@effect-ts/core/Effect"
         */
        resurrect<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, unknown, A>;
        /**
         * @ets_rewrite_method retry_ from "@effect-ts/core/Effect"
         */
        retry<R, E extends I, I, A, R1, O>(this: T.Effect<R, E, A>, policy: Schedule<R1, I, O>, __trace?: string | undefined): T.Effect<R & R1 & Has<Clock>, E, A>;
        /**
         * @ets_rewrite_method retryOrElse_ from "@effect-ts/core/Effect"
         */
        retryOrElse<R, E extends I, I, A, R1, O, R2, E2, A2>(self: Effect<R, E, A>, policy: Schedule<R1, I, O>, orElse: (e: E, o: O) => Effect<R2, E2, A2>, __trace?: string): Effect<R & R1 & R2 & HasClock, E2, A | A2>;
        /**
         * @ets_rewrite_method retryOrElseEither_ from "@effect-ts/core/Effect"
         */
        retryOrElseEither<R, E extends I, A, I, R1, O, R2, E2, A2>(self: Effect<R, E, A>, policy: Schedule<R1, I, O>, orElse: (e: E, o: O) => Effect<R2, E2, A2>, __trace?: string): Effect<R & R1 & R2 & HasClock, E2, E.Either<A2, A>>;
        /**
         * @ets_rewrite_method retryUntilM_ from "@effect-ts/core/Effect"
         */
        retryUntilM<R, E, A, R1, E1>(this: T.Effect<R, E, A>, f: (a: E) => T.Effect<R1, E1, boolean>, __trace?: string | undefined): T.Effect<R & R1, E | E1, A>;
        /**
         * @ets_rewrite_method retryUntil_ from "@effect-ts/core/Effect"
         */
        retryUntil<R, E, A>(this: T.Effect<R, E, A>, f: (a: E) => boolean, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method retryWhileM_ from "@effect-ts/core/Effect"
         */
        retryWhileM<R, E, A, R1, E1>(this: T.Effect<R, E, A>, f: (a: E) => T.Effect<R1, E1, boolean>, __trace?: string | undefined): T.Effect<R & R1, E | E1, A>;
        /**
         * @ets_rewrite_method retryWhile_ from "@effect-ts/core/Effect"
         */
        retryWhile<R, E, A>(this: T.Effect<R, E, A>, f: (a: E) => boolean, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method right from "@effect-ts/core/Effect"
         */
        right<R, E, B, C>(this: T.Effect<R, E, E.Either<B, C>>, __trace?: string | undefined): T.Effect<R, O.Option<E>, C>;
        /**
         * @ets_rewrite_method runPromise from "@effect-ts/core/Effect"
         */
        runPromise<EX, AX>(this: T.Effect<T.DefaultEnv, EX, AX>): Promise<AX>;
        /**
         * @ets_rewrite_method runPromiseExit from "@effect-ts/core/Effect"
         */
        runPromiseExit<EX, AX>(this: T.Effect<T.DefaultEnv, EX, AX>): Promise<Exit<EX, AX>>;
        /**
         * @ets_rewrite_method runFiber from "@effect-ts/core/Effect"
         */
        runFiber<EX, AX>(this: T.Effect<T.DefaultEnv, EX, AX>): Fiber.Fiber<EX, AX>;
        /**
         * @ets_rewrite_method sandbox from "@effect-ts/core/Effect"
         */
        sandbox<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R, Cause<E>, A>;
        /**
         * @ets_rewrite_method sandboxWith_ from "@effect-ts/core/Effect"
         */
        sandboxWith<R, E, A, E2>(this: Effect<R, E, A>, f: (_: Effect<R, Cause<E>, A>) => Effect<R, Cause<E2>, A>, __trace?: string): Effect<R, E2, A>;
        /**
         * @ets_rewrite_method some from "@effect-ts/core/Effect"
         */
        some<R, E, A>(this: T.Effect<R, E, O.Option<A>>, __trace?: string | undefined): T.Effect<R, O.Option<E>, A>;
        /**
         * @ets_rewrite_method someOrElseM_ from "@effect-ts/core/Effect"
         */
        someOrElseM<R, E, A, R2, E2, B>(this: T.Effect<R, E, O.Option<A>>, orElse: T.Effect<R2, E2, B>, __trace?: string | undefined): T.Effect<R & R2, E | E2, A | B>;
        /**
         * @ets_rewrite_method someOrElse_ from "@effect-ts/core/Effect"
         */
        someOrElse<R, E, A, B>(this: T.Effect<R, E, O.Option<A>>, orElse: () => B, __trace?: string | undefined): T.Effect<R, E, A | B>;
        /**
         * @ets_rewrite_method someOrFail_ from "@effect-ts/core/Effect"
         */
        someOrFail<R, E, A, E2>(this: T.Effect<R, E, O.Option<A>>, orFail: () => E2, __trace?: string | undefined): T.Effect<R, E | E2, A>;
        /**
         * @ets_rewrite_method someOrFailException from "@effect-ts/core/Effect"
         */
        someOrFailException<R, E, A>(this: T.Effect<R, E, O.Option<A>>, __trace?: string | undefined): T.Effect<R, E | NoSuchElementException, A>;
        /**
         * @ets_rewrite_method summarized_ from "@effect-ts/core/Effect"
         */
        summarized<R, E, A, R2, E2, B, C>(this: Effect<R, E, A>, summary: Effect<R2, E2, B>, f: (start: B, end: B) => C, __trace?: string): Effect<R & R2, E | E2, Tp.Tuple<[C, A]>>;
        /**
         * @ets_rewrite_method supervised_ from "@effect-ts/core/Effect"
         */
        supervised<R, E, A>(this: T.Effect<R, E, A>, supervisor: Supervisor<any>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method tap_ from "@effect-ts/core/Effect"
         */
        tap<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: (a: AX) => T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, AX>;
        /**
         * @ets_rewrite_method tapError_ from "@effect-ts/core/Effect"
         */
        tapError<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: (e: EX) => T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, AX>;
        /**
         * @ets_rewrite_method tapCause_ from "@effect-ts/core/Effect"
         */
        tapCause<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: (e: Cause<EX>) => T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, AX>;
        /**
         * @ets_rewrite_method tapBoth_ from "@effect-ts/core/Effect"
         */
        tapBoth<RX, EX, AX, R2, E2, B, R3, E3, C>(this: T.Effect<RX, EX, AX>, f: (e: EX) => T.Effect<R2, E2, B>, g: (e: AX) => T.Effect<R2, E3, C>, __trace?: string): T.Effect<RX & R2 & R3, EX | E2 | E3, AX>;
        /**
         * @ets_rewrite_method fromRawEffect from "@effect-ts/core/Effect/Layer"
         */
        toLayer<RX, EX, AX>(this: T.Effect<RX, EX, AX>): Layer<RX, EX, AX>;
        /**
         * @ets_rewrite_method fromEffect_ from "@effect-ts/core/Effect/Layer"
         */
        toLayer<RX, EX, AX>(this: T.Effect<RX, EX, AX>, tag: Tag<AX>): Layer<RX, EX, Has<AX>>;
        /**
         * @ets_rewrite_method fromEffect from "@effect-ts/core/Effect/Managed"
         */
        toManaged<RX, EX, AX>(this: T.Effect<RX, EX, AX>): M.Managed<RX, EX, AX>;
        /**
         * @ets_rewrite_method toManagedRelease_ from "@effect-ts/core/Effect"
         */
        toManaged<A, R1, E1, R>(this: T.Effect<R1, E1, A>, release: (a: A) => T.Effect<R, never, any>): M.Managed<R1 & R, E1, A>;
        /**
         * @ets_rewrite_method timed from "@effect-ts/core/Effect"
         */
        timed<R, E, A>(this: T.Effect<R, E, A>, __trace?: string | undefined): T.Effect<R & Has<Clock>, E, Tp.Tuple<[number, A]>>;
        /**
         * @ets_rewrite_method timedWith_ from "@effect-ts/core/Effect"
         */
        timedWith<R, E, A, R2, E2>(this: T.Effect<R, E, A>, msTime: T.Effect<R2, E2, number>, __trace?: string | undefined): T.Effect<R & R2, E | E2, Tp.Tuple<[number, A]>>;
        /**
         * @ets_rewrite_method timeoutFail_ from "@effect-ts/core/Effect"
         */
        timeoutFail<R, E, E2, A>(this: T.Effect<R, E, A>, d: number, e: () => E2, __trace?: string | undefined): T.Effect<R & Has<Clock>, E | E2, A>;
        /**
         * @ets_rewrite_method timeoutTo_ from "@effect-ts/core/Effect"
         */
        timeoutTo<R, E, A, B, B2>(this: T.Effect<R, E, A>, delay: number, orElse: B, f: (a: A) => B2, __trace?: string | undefined): T.Effect<R & Has<Clock>, E, B | B2>;
        /**
         * @ets_rewrite_method timeout_ from "@effect-ts/core/Effect"
         */
        timeout<R, E, A>(this: T.Effect<R, E, A>, d: number, __trace?: string | undefined): T.Effect<R & Has<Clock>, E, O.Option<A>>;
        /**
         * @ets_rewrite_method to_ from "@effect-ts/core/Effect"
         */
        to<R, E, A>(this: T.Effect<R, E, A>, promise: P.Promise<E, A>, __trace?: string | undefined): T.Effect<R, never, boolean>;
        /**
         * @ets_rewrite_method traced from "@effect-ts/core/Effect"
         */
        traced<R, E, A>(this: T.Effect<R, E, A>): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method tracingStatus_ from "@effect-ts/core/Effect"
         */
        tracingStatus<R, E, A>(this: T.Effect<R, E, A>, flag: boolean): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method uncause from "@effect-ts/core/Effect"
         */
        uncause<R, E>(this: T.RIO<R, Cause<E>>, __trace?: string | undefined): T.Effect<R, E, void>;
        /**
         * @ets_rewrite_method unfailable from "smart:identity"
         */
        unfailable<R, A>(this: T.Effect<R, never, A>): T.RIO<R, A>;
        /**
         * @ets_rewrite_method uninterruptible from "@effect-ts/core/Effect"
         */
        uninterruptible: <R, E, A>(effect: T.Effect<R, E, A>) => T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method unlessM_ from "@effect-ts/core/Effect"
         */
        unlessM<R2, E2, R, E, A>(this: T.Effect<R, E, A>, bool: T.Effect<R2, E2, boolean>, __trace?: string | undefined): T.Effect<R2 & R, E2 | E, void>;
        /**
         * @ets_rewrite_method unless_ from "@effect-ts/core/Effect"
         */
        unless<R, E, A>(this: T.Effect<R, E, A>, pred: () => boolean, __trace?: string | undefined): T.Effect<R, E, void>;
        /**
         * @ets_rewrite_method unrefineWith_ from "@effect-ts/core/Effect"
         */
        unrefineWith<R, E, E1, E2, A>(this: T.Effect<R, E, A>, pf: (u: unknown) => O.Option<E1>, f: (e: E) => E2, __trace?: string | undefined): T.Effect<R, E1 | E2, A>;
        /**
         * @ets_rewrite_method unrefine_ from "@effect-ts/core/Effect"
         */
        unrefine<R, E, A, E1>(this: T.Effect<R, E, A>, pf: (u: unknown) => O.Option<E1>, __trace?: string | undefined): T.Effect<R, E | E1, A>;
        /**
         * @ets_rewrite_method unrefine_ from "@effect-ts/core/Effect"
         */
        unsandbox<R, E, A>(this: T.Effect<R, Cause<E>, A>, __trace?: string | undefined): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method untraced from "@effect-ts/core/Effect"
         */
        untraced<R, E, A>(this: T.Effect<R, E, A>): T.Effect<R, E, A>;
        /**
         * @ets_rewrite_method updateService_ from "@effect-ts/core/Effect"
         */
        updateService<T, R, E, A>(this: T.Effect<R, E, A>, tag: Tag<T>, f: (_: T) => T, __trace?: string | undefined): T.Effect<R & Has<T>, E, A>;
        /**
         * @ets_rewrite_method whenM_ from "@effect-ts/core/Effect"
         */
        whenM<R1, E1, A, R, E>(this: T.Effect<R1, E1, A>, predicate: T.Effect<R, E, boolean>, __trace?: string | undefined): T.Effect<R & R1, E1 | E, void>;
        /**
         * @ets_rewrite_method when_ from "@effect-ts/core/Effect"
         */
        when<R1, E1, A>(this: T.Effect<R1, E1, A>, predicate: () => boolean, __trace?: string | undefined): T.Effect<R1, E1, O.Option<A>>;
        /**
         * @ets_rewrite_method zip_ from "@effect-ts/core/Effect"
         */
        zip<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, Tp.Tuple<[AX, B]>>;
        /**
         * @ets_rewrite_method zipPar_ from "@effect-ts/core/Effect"
         */
        zipPar<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, Tp.Tuple<[AX, B]>>;
        /**
         * @ets_rewrite_method zipRight_ from "@effect-ts/core/Effect"
         */
        zipRight<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, B>;
        /**
         * @ets_rewrite_method zipRightPar_ from "@effect-ts/core/Effect"
         */
        zipRightPar<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, B>;
        /**
         * @ets_rewrite_method zipLeft_ from "@effect-ts/core/Effect"
         */
        zipLeft<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, AX>;
        /**
         * @ets_rewrite_method zipLeftPar_ from "@effect-ts/core/Effect"
         */
        zipLeftPar<RX, EX, AX, R2, E2, B>(this: T.Effect<RX, EX, AX>, f: T.Effect<R2, E2, B>, __trace?: string): T.Effect<RX & R2, EX | E2, AX>;
        /**
         * @ets_rewrite_method zipWith_ from "@effect-ts/core/Effect"
         */
        zipWith<R, E, A, R2, E2, A2, B>(this: T.Effect<R, E, A>, that: T.Effect<R2, E2, A2>, f: (a: A, b: A2) => B, __trace?: string | undefined): T.Effect<R & R2, E | E2, B>;
        /**
         * @ets_rewrite_method zipWithPar_ from "@effect-ts/core/Effect"
         */
        zipWithPar<R, E, A, R2, E2, A2, B>(this: T.Effect<R, E, A>, that: T.Effect<R2, E2, A2>, f: (a: A, b: A2) => B, __trace?: string | undefined): T.Effect<R & R2, E | E2, B>;
    }
}
//# sourceMappingURL=effect.d.ts.map