effect 3.3.5 → 3.4.1

package/dist/dts/Micro.d.ts

@@ -0,0 +1,2010 @@
+/**
+ * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
+ *
+ * @since 3.4.0
+ * @experimental
+ */
+import type { Channel, ChannelTypeId } from "./Channel.js";
+import * as Context from "./Context.js";
+import type { Effect, EffectTypeId } from "./Effect.js";
+import * as Either from "./Either.js";
+import { type LazyArg } from "./Function.js";
+import type { TypeLambda } from "./HKT.js";
+import type { Inspectable } from "./Inspectable.js";
+import * as Option from "./Option.js";
+import { type Pipeable } from "./Pipeable.js";
+import { type Predicate, type Refinement } from "./Predicate.js";
+import type { ReadonlyRecord } from "./Record.js";
+import type { Sink, SinkTypeId } from "./Sink.js";
+import type { Stream, StreamTypeId } from "./Stream.js";
+import type { Concurrency, Covariant, Equals, NoInfer, NotFunction, Simplify } from "./Types.js";
+import { YieldWrap } from "./Utils.js";
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category type ids
+ */
+export declare const TypeId: unique symbol;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category type ids
+ */
+export type TypeId = typeof TypeId;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category symbols
+ */
+export declare const runSymbol: unique symbol;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category symbols
+ */
+export type runSymbol = typeof runSymbol;
+/**
+ * A lightweight alternative to the `Effect` data type, with a subset of the functionality.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category models
+ */
+export interface Micro<out A, out E = never, out R = never> extends Effect<A, E, R> {
+    readonly [TypeId]: Micro.Variance<A, E, R>;
+    readonly [runSymbol]: (env: Env<any>, onResult: (result: Result<A, E>) => void) => void;
+    [Symbol.iterator](): MicroIterator<Micro<A, E, R>>;
+}
+/**
+ * @category type lambdas
+ * @since 3.4.1
+ */
+export interface MicroTypeLambda extends TypeLambda {
+    readonly type: Micro<this["Target"], this["Out1"], this["Out2"]>;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ */
+export declare namespace Micro {
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    interface Variance<A, E, R> {
+        _A: Covariant<A>;
+        _E: Covariant<E>;
+        _R: Covariant<R>;
+    }
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type Success<T> = T extends Micro<infer _A, infer _E, infer _R> ? _A : never;
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type Error<T> = T extends Micro<infer _A, infer _E, infer _R> ? _E : never;
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type Context<T> = T extends Micro<infer _A, infer _E, infer _R> ? _R : never;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category guards
+ */
+export declare const isMicro: (u: unknown) => u is Micro<any, any, any>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category models
+ */
+export interface MicroIterator<T extends Micro<any, any, any>> {
+    next(...args: ReadonlyArray<any>): IteratorResult<YieldWrap<T>, Micro.Success<T>>;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const FailureTypeId: unique symbol;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export type FailureTypeId = typeof FailureTypeId;
+/**
+ * A Micro Failure is a data type that represents the different ways a Micro can fail.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export type Failure<E> = Failure.Unexpected | Failure.Expected<E> | Failure.Aborted;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare namespace Failure {
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    interface Proto<Tag extends string, E> extends Pipeable, globalThis.Error {
+        readonly [FailureTypeId]: {
+            _E: Covariant<E>;
+        };
+        readonly _tag: Tag;
+        readonly traces: ReadonlyArray<string>;
+    }
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category failure
+     */
+    interface Unexpected extends Proto<"Unexpected", never> {
+        readonly defect: unknown;
+    }
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category failure
+     */
+    interface Expected<E> extends Proto<"Expected", E> {
+        readonly error: E;
+    }
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category failure
+     */
+    interface Aborted extends Proto<"Aborted", never> {
+    }
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const FailureExpected: <E>(error: E, traces?: ReadonlyArray<string>) => Failure<E>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const FailureUnexpected: (defect: unknown, traces?: ReadonlyArray<string>) => Failure<never>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const FailureAborted: (traces?: ReadonlyArray<string>) => Failure<never>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const failureIsExpected: <E>(self: Failure<E>) => self is Failure.Expected<E>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const failureIsUnexpected: <E>(self: Failure<E>) => self is Failure.Unexpected;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const failureIsAborted: <E>(self: Failure<E>) => self is Failure.Aborted;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const failureSquash: <E>(self: Failure<E>) => unknown;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category failure
+ */
+export declare const failureWithTrace: {
+    (trace: string): <E>(self: Failure<E>) => Failure<E>;
+    <E>(self: Failure<E>, trace: string): Failure<E>;
+};
+/**
+ * The Micro Result type is a data type that represents the result of a Micro
+ * computation.
+ *
+ * It uses the `Either` data type to represent the success and failure cases.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export type Result<A, E = never> = Either.Either<A, Failure<E>>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const ResultAborted: Result<never>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const ResultSuccess: <A>(a: A) => Result<A, never>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const ResultFail: <E>(e: E) => Result<never, E>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const ResultFailUnexpected: (defect: unknown) => Result<never>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const ResultFailWith: <E>(failure: Failure<E>) => Result<never, E>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const resultIsSuccess: <A, E>(self: Result<A, E>) => self is Either.Right<Failure<E>, A>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const resultIsFailure: <A, E>(self: Result<A, E>) => self is Either.Left<Failure<E>, A>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const resultIsAborted: <A, E>(self: Result<A, E>) => self is Either.Left<Failure.Aborted, A>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const resultIsFailureExpected: <A, E>(self: Result<A, E>) => self is Either.Left<Failure.Expected<E>, A>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const resultIsFailureUnexpected: <A, E>(self: Result<A, E>) => self is Either.Left<Failure.Unexpected, A>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category result
+ */
+export declare const resultVoid: Result<void>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const EnvTypeId: unique symbol;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export type EnvTypeId = typeof EnvTypeId;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export interface Env<R> extends Pipeable {
+    readonly [EnvTypeId]: {
+        _R: Covariant<R>;
+    };
+    readonly refs: ReadonlyRecord<string, unknown>;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const EnvRefTypeId: unique symbol;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export type EnvRefTypeId = typeof EnvRefTypeId;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export interface EnvRef<A> {
+    readonly [EnvRefTypeId]: EnvRefTypeId;
+    readonly key: string;
+    readonly initial: A;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const envMake: <R = never>(refs: Record<string, unknown>) => Env<R>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const envUnsafeMakeEmpty: () => Env<never>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const envGet: {
+    <A>(ref: EnvRef<A>): <R>(self: Env<R>) => A;
+    <A, R>(self: Env<R>, ref: EnvRef<A>): A;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const envSet: {
+    <A>(ref: EnvRef<A>, value: A): <R>(self: Env<R>) => Env<R>;
+    <A, R>(self: Env<R>, ref: EnvRef<A>, value: A): Env<R>;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const envMutate: {
+    (f: (map: Record<string, unknown>) => void): <R>(self: Env<R>) => Env<R>;
+    <R>(self: Env<R>, f: (map: Record<string, unknown>) => void): Env<R>;
+};
+/**
+ * Access the given `Context.Tag` from the environment.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const service: <I, S>(tag: Context.Tag<I, S>) => Micro<S, never, I>;
+/**
+ * Access the given `Context.Tag` from the environment, without tracking the
+ * dependency at the type level.
+ *
+ * It will return an `Option` of the service, depending on whether it is
+ * available in the environment or not.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const serviceOption: <I, S>(tag: Context.Tag<I, S>) => Micro<Option.Option<S>>;
+/**
+ * Retrieve the current value of the given `EnvRef`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const getEnvRef: <A>(envRef: EnvRef<A>) => Micro<A>;
+/**
+ * Set the value of the given `EnvRef` for the duration of the effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const locally: {
+    <A>(fiberRef: EnvRef<A>, value: A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R>;
+    <XA, E, R, A>(self: Micro<XA, E, R>, fiberRef: EnvRef<A>, value: A): Micro<XA, E, R>;
+};
+/**
+ * Access the current `Context` from the environment.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const context: <R>() => Micro<Context.Context<R>>;
+/**
+ * Merge the given `Context` with the current context.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const provideContext: {
+    <XR>(context: Context.Context<XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, XR>>;
+    <A, E, R, XR>(self: Micro<A, E, R>, context: Context.Context<XR>): Micro<A, E, Exclude<R, XR>>;
+};
+/**
+ * Add the provided service to the current context.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const provideService: {
+    <I, S>(tag: Context.Tag<I, S>, service: S): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, I>>;
+    <A, E, R, I, S>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>>;
+};
+/**
+ * Create a service using the provided `Micro` effect, and add it to the
+ * current context.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment
+ */
+export declare const provideServiceMicro: {
+    <I, S, E2, R2>(tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | E2, Exclude<R, I> | R2>;
+    <A, E, R, I, S, E2, R2>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, acquire: Micro<S, E2, R2>): Micro<A, E | E2, Exclude<R, I> | R2>;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+export declare const envRefMake: <A>(key: string, initial: LazyArg<A>) => EnvRef<A>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+export declare const currentAbortController: EnvRef<AbortController>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+export declare const currentAbortSignal: EnvRef<AbortSignal>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+export declare const currentContext: EnvRef<Context.Context<never>>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+export declare const currentConcurrency: EnvRef<"unbounded" | number>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ */
+export declare const currentMaxDepthBeforeYield: EnvRef<number>;
+/**
+ * If you have a `Micro` that uses `concurrency: "inherit"`, you can use this
+ * api to control the concurrency of that `Micro` when it is run.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category environment refs
+ * @example
+ * import * as Micro from "effect/Micro"
+ *
+ * Micro.forEach([1, 2, 3], (n) => Micro.succeed(n), {
+ *   concurrency: "inherit"
+ * }).pipe(
+ *   Micro.withConcurrency(2) // use a concurrency of 2
+ * )
+ */
+export declare const withConcurrency: {
+    (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>;
+};
+/**
+ * A low-level constructor for creating a `Micro` effect. It takes a function
+ * that receives an environment and a callback which should be called with the
+ * result of the effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const make: <A, E, R>(run: (env: Env<R>, onResult: (result: Result<A, E>) => void) => void) => Micro<A, E, R>;
+/**
+ * Converts a `Result` into a `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const fromResult: <A, E>(self: Result<A, E>) => Micro<A, E>;
+/**
+ * Converts a lazy `Result` into a `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const fromResultSync: <A, E>(self: LazyArg<Result<A, E>>) => Micro<A, E>;
+/**
+ * Creates a `Micro` effect that will succeed with the specified constant value.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const succeed: <A>(a: A) => Micro<A>;
+/**
+ * Creates a `Micro` effect that will succeed with `Option.Some` of the value.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const succeedSome: <A>(a: A) => Micro<Option.Option<A>>;
+/**
+ * Creates a `Micro` effect that will succeed with `Option.None`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const succeedNone: Micro<Option.Option<never>>;
+/**
+ * Creates a `Micro` effect that will fail with the specified error.
+ *
+ * This will result in a `FailureExpected`, where the error is tracked at the
+ * type level.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const fail: <E>(e: E) => Micro<never, E>;
+/**
+ * Creates a `Micro` effect that will fail with the lazily evaluated error.
+ *
+ * This will result in a `FailureExpected`, where the error is tracked at the
+ * type level.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const failSync: <E>(e: LazyArg<E>) => Micro<never, E>;
+/**
+ * Creates a `Micro` effect that will die with the specified error.
+ *
+ * This will result in a `FailureUnexpected`, where the error is not tracked at
+ * the type level.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const die: (defect: unknown) => Micro<never>;
+/**
+ * Creates a `Micro` effect that will fail with the specified `Failure`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const failWith: <E>(failure: Failure<E>) => Micro<never, E>;
+/**
+ * Creates a `Micro` effect that will fail with the lazily evaluated `Failure`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const failWithSync: <E>(failure: LazyArg<Failure<E>>) => Micro<never, E>;
+/**
+ * Creates a `Micro` effect that will succeed with the lazily evaluated value.
+ *
+ * If the evaluation of the value throws an error, the effect will fail with
+ * `FailureUnexpected`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const sync: <A>(evaluate: LazyArg<A>) => Micro<A>;
+/**
+ * Converts an `Option` into a `Micro` effect, that will fail with a
+ * `Option.None` if the option is `None`. Otherwise, it will succeed with the
+ * value of the option.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const fromOption: <A>(option: Option.Option<A>) => Micro<A, Option.None<never>>;
+/**
+ * Converts an `Either` into a `Micro` effect, that will fail with the left side
+ * of the either if it is a `Left`. Otherwise, it will succeed with the right
+ * side of the either.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const fromEither: <R, L>(either: Either.Either<R, L>) => Micro<R, L>;
+/**
+ * Lazily creates a `Micro` effect from the given side-effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const suspend: <A, E, R>(evaluate: LazyArg<Micro<A, E, R>>) => Micro<A, E, R>;
+declare const void_: Micro<void>;
+export { 
+/**
+ * A `Micro` effect that will succeed with `void` (`undefined`).
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+void_ as void };
+/**
+ * Create a `Micro` effect from an asynchronous computation.
+ *
+ * You can return a cleanup effect that will be run when the effect is aborted.
+ * It is also passed an `AbortSignal` that is triggered when the effect is
+ * aborted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const async: <A, E = never, R = never>(register: (resume: (effect: Micro<A, E, R>) => void, signal: AbortSignal) => void | Micro<void, never, R>) => Micro<A, E, R>;
+declare const try_: <A, E>(options: {
+    try: LazyArg<A>;
+    catch: (error: unknown) => E;
+}) => Micro<A, E>;
+export { 
+/**
+ * The `Micro` equivalent of a try / catch block, which allows you to map
+ * thrown errors to a specific error type.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ * @example
+ * import { Micro } from "effect"
+ *
+ * Micro.try({
+ *   try: () => throw new Error("boom"),
+ *   catch: (cause) => new Error("caught", { cause })
+ * })
+ */
+try_ as try };
+/**
+ * Wrap a `Promise` into a `Micro` effect. Any errors will result in a
+ * `FailureUnexpected`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const promise: <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>) => Micro<A>;
+/**
+ * Wrap a `Promise` into a `Micro` effect. Any errors will be caught and
+ * converted into a specific error type.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ * @example
+ * import { Micro } from "effect"
+ *
+ * Micro.tryPromise({
+ *   try: () => Promise.resolve("success"),
+ *   catch: (cause) => new Error("caught", { cause })
+ * })
+ */
+export declare const tryPromise: <A, E>(options: {
+    readonly try: (signal: AbortSignal) => PromiseLike<A>;
+    readonly catch: (error: unknown) => E;
+}) => Micro<A, E>;
+/**
+ * Pause the execution of the current `Micro` effect, and resume it on the next
+ * iteration of the event loop.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const yieldNow: Micro<void>;
+/**
+ * Flush any yielded effects that are waiting to be executed.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const yieldFlush: Micro<void>;
+/**
+ * A `Micro` that will never succeed or fail. It wraps `setInterval` to prevent
+ * the Javascript runtime from exiting.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const never: Micro<never>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category constructors
+ */
+export declare const gen: <Eff extends YieldWrap<Micro<any, any, any>>, AEff>(f: () => Generator<Eff, AEff, never>) => Micro<AEff, [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A, infer E, infer _R>>] ? E : never, [Eff] extends [never] ? never : [Eff] extends [YieldWrap<Micro<infer _A_1, infer _E, infer R>>] ? R : never>;
+/**
+ * Flattens any nested `Micro` effects, merging the error and requirement types.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const flatten: <A, E, R, E2, R2>(self: Micro<Micro<A, E, R>, E2, R2>) => Micro<A, E | E2, R | R2>;
+/**
+ * Transforms the success value of the `Micro` effect with the specified
+ * function.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const map: {
+    <A, B>(f: (a: A) => B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>;
+    <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R>;
+};
+/**
+ * Create a `Micro` effect that will replace the success value of the given
+ * effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const as: {
+    <A, B>(value: B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>;
+    <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R>;
+};
+/**
+ * Wrap the success value of this `Micro` effect in an `Option.Some`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const asSome: <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E, R>;
+/**
+ * Map the success value of this `Micro` effect to another `Micro` effect, then
+ * flatten the result.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const flatMap: {
+    <A, B, E2, R2>(f: (a: A) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<B, E | E2, R | R2>;
+};
+/**
+ * Swap the error and success types of the `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const flip: <A, E, R>(self: Micro<A, E, R>) => Micro<E, A, R>;
+/**
+ * A more flexible version of `flatMap`, that combines `map` and `flatMap` into
+ * a single api.
+ *
+ * It also allows you to pass in a `Micro` effect directly, which will be
+ * executed after the current effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const andThen: {
+    <A, X>(f: (a: A) => X): <E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
+    <X>(f: NotFunction<X>): <A, E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
+    <A, E, R, X>(self: Micro<A, E, R>, f: (a: A) => X): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
+    <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer A1, infer E1, infer R1>] ? Micro<A1, E | E1, R | R1> : Micro<X, E, R>;
+};
+/**
+ * Execute a side effect from the success value of the `Micro` effect.
+ *
+ * It is similar to the `andThen` api, but the success value is ignored.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const tap: {
+    <A, X>(f: (a: NoInfer<A>) => X): <E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
+    <X>(f: NotFunction<X>): <A, E, R>(self: Micro<A, E, R>) => [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
+    <A, E, R, X>(self: Micro<A, E, R>, f: (a: NoInfer<A>) => X): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
+    <A, E, R, X>(self: Micro<A, E, R>, f: NotFunction<X>): [X] extends [Micro<infer _A1, infer E1, infer R1>] ? Micro<A, E | E1, R | R1> : Micro<A, E, R>;
+};
+/**
+ * Replace the success value of the `Micro` effect with `void`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const asVoid: <A, E, R>(self: Micro<A, E, R>) => Micro<void, E, R>;
+/**
+ * Access the `Result` of the given `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const asResult: <A, E, R>(self: Micro<A, E, R>) => Micro<Result<A, E>, never, R>;
+/**
+ * Replace the error type of the given `Micro` with the full `Failure` object.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category mapping & sequencing
+ */
+export declare const sandbox: <A, E, R>(self: Micro<A, E, R>) => Micro<A, Failure<E>, R>;
+/**
+ * Returns an effect that races all the specified effects,
+ * yielding the value of the first effect to succeed with a value. Losers of
+ * the race will be interrupted immediately
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category sequencing
+ */
+export declare const raceAll: <Eff extends Micro<any, any, any>>(all: Iterable<Eff>) => Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>>;
+/**
+ * Returns an effect that races all the specified effects,
+ * yielding the value of the first effect to succeed or fail. Losers of
+ * the race will be interrupted immediately
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category sequencing
+ */
+export declare const raceAllFirst: <Eff extends Micro<any, any, any>>(all: Iterable<Eff>) => Micro<Micro.Success<Eff>, Micro.Error<Eff>, Micro.Context<Eff>>;
+/**
+ * Returns an effect that races two effects, yielding the value of the first
+ * effect to succeed. Losers of the race will be interrupted immediately
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category sequencing
+ */
+export declare const race: {
+    <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
+};
+/**
+ * Returns an effect that races two effects, yielding the value of the first
+ * effect to succeed *or* fail. Losers of the race will be interrupted immediately
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category sequencing
+ */
+export declare const raceFirst: {
+    <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
+};
+/**
+ * Combine two `Micro` effects into a single effect that produces a tuple of
+ * their results.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category zipping
+ */
+export declare const zip: {
+    <A2, E2, R2>(that: Micro<A2, E2, R2>, options?: {
+        readonly concurrent?: boolean | undefined;
+    } | undefined): <A, E, R>(self: Micro<A, E, R>) => Micro<[A, A2], E2 | E, R2 | R>;
+    <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>, options?: {
+        readonly concurrent?: boolean | undefined;
+    } | undefined): Micro<[A, A2], E | E2, R | R2>;
+};
+/**
+ * Filter the specified effect with the provided function, failing with specified
+ * `Failure` if the predicate fails.
+ *
+ * In addition to the filtering capabilities discussed earlier, you have the option to further
+ * refine and narrow down the type of the success channel by providing a
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category filtering & conditionals
+ */
+export declare const filterOrFailWith: {
+    <A, B extends A, E2>(refinement: Refinement<A, B>, orFailWith: (a: NoInfer<A>) => Failure<E2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>;
+    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => Failure<E2>): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>;
+    <A, E, R, B extends A, E2>(self: Micro<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => Failure<E2>): Micro<B, E | E2, R>;
+    <A, E, R, E2>(self: Micro<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => Failure<E2>): Micro<A, E | E2, R>;
+};
+/**
+ * Filter the specified effect with the provided function, failing with specified
+ * error if the predicate fails.
+ *
+ * In addition to the filtering capabilities discussed earlier, you have the option to further
+ * refine and narrow down the type of the success channel by providing a
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category filtering & conditionals
+ */
+export declare const filterOrFail: {
+    <A, B extends A, E2>(refinement: Refinement<A, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>;
+    <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>;
+    <A, E, R, B extends A, E2>(self: Micro<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): Micro<B, E | E2, R>;
+    <A, E, R, E2>(self: Micro<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): Micro<A, E | E2, R>;
+};
+/**
+ * The moral equivalent of `if (p) exp`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category filtering & conditionals
+ */
+export declare const when: {
+    <E2 = never, R2 = never>(condition: LazyArg<boolean> | Micro<boolean, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E | E2, R | R2>;
+    <A, E, R, E2 = never, R2 = never>(self: Micro<A, E, R>, condition: LazyArg<boolean> | Micro<boolean, E2, R2>): Micro<Option.Option<A>, E | E2, R | R2>;
+};
+/**
+ * Repeat the given `Micro` using the provided options.
+ *
+ * The `while` predicate will be checked after each iteration, and can use the
+ * fall `Result` of the effect to determine if the repetition should continue.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category repetition
+ */
+export declare const repeatResult: {
+    <A, E>(options: {
+        while: Predicate<Result<A, E>>;
+        times?: number | undefined;
+        delay?: DelayFn | undefined;
+    }): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    <A, E, R>(self: Micro<A, E, R>, options: {
+        while: Predicate<Result<A, E>>;
+        times?: number | undefined;
+        delay?: DelayFn | undefined;
+    }): Micro<A, E, R>;
+};
+/**
+ * Repeat the given `Micro` effect using the provided options. Only successful
+ * results will be repeated.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category repetition
+ */
+export declare const repeat: {
+    <A, E>(options?: {
+        while?: Predicate<A> | undefined;
+        times?: number | undefined;
+        delay?: DelayFn | undefined;
+    } | undefined): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    <A, E, R>(self: Micro<A, E, R>, options?: {
+        while?: Predicate<A> | undefined;
+        times?: number | undefined;
+        delay?: DelayFn | undefined;
+    } | undefined): Micro<A, E, R>;
+};
+/**
+ * Repeat the given `Micro` effect forever, only stopping if the effect fails.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category repetition
+ */
+export declare const forever: <A, E, R>(self: Micro<A, E, R>) => Micro<never, E, R>;
+/**
+ * Represents a function that can be used to calculate the delay between
+ * repeats.
+ *
+ * The function takes the current attempt number and the elapsed time since
+ * the first attempt, and returns the delay for the next attempt. If the
+ * function returns `None`, the repetition will stop.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+export type DelayFn = (attempt: number, elapsed: number) => Option.Option<number>;
+/**
+ * Create a `DelayFn` that will generate a duration with an exponential backoff.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+export declare const delayExponential: (baseMillis: number, factor?: number) => DelayFn;
+/**
+ * Create a `DelayFn` that will generate a duration with fixed intervals.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+export declare const delaySpaced: (millis: number) => DelayFn;
+/**
+ * Transform a `DelayFn` to one that will have a duration that will never exceed
+ * the specified maximum.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+export declare const delayWithMax: {
+    (max: number): (self: DelayFn) => DelayFn;
+    (self: DelayFn, max: number): DelayFn;
+};
+/**
+ * Transform a `DelayFn` to one that will stop repeating after the specified
+ * amount of time.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+export declare const delayWithMaxElapsed: {
+    (max: number): (self: DelayFn) => DelayFn;
+    (self: DelayFn, max: number): DelayFn;
+};
+/**
+ * Transform a `DelayFn` to one that will stop repeating after the specified
+ * number of attempts.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delay fn
+ */
+export declare const delayWithRecurs: {
+    (n: number): (self: DelayFn) => DelayFn;
+    (self: DelayFn, n: number): DelayFn;
+};
+/**
+ * Catch the full `Failure` object of the given `Micro` effect, allowing you to
+ * recover from any kind of failure.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const catchFailure: {
+    <E, B, E2, R2>(f: (failure: NoInfer<Failure<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (failure: NoInfer<Failure<E>>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
+};
+/**
+ * Selectively catch a `Failure` object of the given `Micro` effect,
+ * using the provided predicate to determine if the failure should be caught.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const catchFailureIf: {
+    <E, B, E2, R2, EB extends Failure<E>>(refinement: Refinement<Failure<E>, EB>, f: (failure: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
+    <E, B, E2, R2>(predicate: Predicate<Failure<NoInfer<E>>>, f: (failure: NoInfer<Failure<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
+    <A, E, R, B, E2, R2, EB extends Failure<E>>(self: Micro<A, E, R>, refinement: Refinement<Failure<E>, EB>, f: (failure: EB) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: Predicate<Failure<NoInfer<E>>>, f: (failure: NoInfer<Failure<E>>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
+};
+/**
+ * Catch the error of the given `Micro` effect, allowing you to recover from it.
+ *
+ * It only catches expected (`FailureExpected`) errors.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const catchExpected: {
+    <E, B, E2, R2>(f: (e: NoInfer<E>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (e: NoInfer<E>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
+};
+/**
+ * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const catchUnexpected: {
+    <E, B, E2, R2>(f: (defect: unknown) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A | B, E | E2, R | R2>;
+};
+/**
+ * Perform a side effect using the full `Failure` object of the given `Micro`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const tapFailure: {
+    <E, B, E2, R2>(f: (a: NoInfer<Failure<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: NoInfer<Failure<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+};
+/**
+ * Perform a side effect using if a `Failure` object matches the specified
+ * predicate.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const tapFailureIf: {
+    <E, B, E2, R2, EB extends Failure<E>>(refinement: Refinement<Failure<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <E, B, E2, R2>(predicate: (failure: NoInfer<Failure<E>>) => boolean, f: (a: NoInfer<Failure<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2, EB extends Failure<E>>(self: Micro<A, E, R>, refinement: Refinement<Failure<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: (failure: NoInfer<Failure<E>>) => boolean, f: (a: NoInfer<Failure<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+};
+/**
+ * Perform a side effect from expected errors of the given `Micro`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const tapExpected: {
+    <E, B, E2, R2>(f: (a: NoInfer<E>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: NoInfer<E>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+};
+/**
+ * Perform a side effect from unexpected errors of the given `Micro`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const tapUnexpected: {
+    <E, B, E2, R2>(f: (defect: unknown) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+};
+/**
+ * Catch any expected errors that match the specified predicate.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const catchIf: {
+    <E, EB extends E, B, E2, R2>(pred: Refinement<E, EB>, f: (a: NoInfer<EB>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
+    <E, B, E2, R2>(pred: Predicate<NoInfer<E>>, f: (a: NoInfer<E>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
+    <A, E, R, EB extends E, B, E2, R2>(self: Micro<A, E, R>, pred: Refinement<E, EB>, f: (a: NoInfer<EB>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
+    <A, E, R, B, E2, R2>(self: Micro<A, E, R>, pred: Predicate<NoInfer<E>>, f: (a: NoInfer<E>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
+};
+/**
+ * Recovers from the specified tagged error.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const catchTag: {
+    <K extends E extends {
+        _tag: string;
+    } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: Extract<E, {
+        _tag: K;
+    }>) => Micro<A1, E1, R1>): <A, R>(self: Micro<A, E, R>) => Micro<A1 | A, E1 | Exclude<E, {
+        _tag: K;
+    }>, R1 | R>;
+    <A, E, R, K extends E extends {
+        _tag: string;
+    } ? E["_tag"] : never, R1, E1, A1>(self: Micro<A, E, R>, k: K, f: (e: Extract<E, {
+        _tag: K;
+    }>) => Micro<A1, E1, R1>): Micro<A | A1, E1 | Exclude<E, {
+        _tag: K;
+    }>, R | R1>;
+};
+/**
+ * Transform the full `Failure` object of the given `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const mapFailure: {
+    <E, E2>(f: (a: Failure<E>) => Failure<E2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>;
+    <A, E, R, E2>(self: Micro<A, E, R>, f: (a: Failure<E>) => Failure<E2>): Micro<A, E2, R>;
+};
+/**
+ * Transform any expected errors of the given `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const mapError: {
+    <E, E2>(f: (a: E) => E2): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>;
+    <A, E, R, E2>(self: Micro<A, E, R>, f: (a: E) => E2): Micro<A, E2, R>;
+};
+/**
+ * Elevate any expected errors of the given `Micro` effect to unexpected errors,
+ * resulting in an error type of `never`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const orDie: <A, E, R>(self: Micro<A, E, R>) => Micro<A, never, R>;
+/**
+ * Recover from all errors by succeeding with the given value.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const orElseSucceed: {
+    <B>(f: LazyArg<B>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | B, never, R>;
+    <A, E, R, B>(self: Micro<A, E, R>, f: LazyArg<B>): Micro<A | B, never, R>;
+};
+/**
+ * Ignore any expected errors of the given `Micro` effect, returning `void`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const ignore: <A, E, R>(self: Micro<A, E, R>) => Micro<void, never, R>;
+/**
+ * Ignore any expected errors of the given `Micro` effect, returning `void`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const ignoreLogged: <A, E, R>(self: Micro<A, E, R>) => Micro<void, never, R>;
+/**
+ * Replace the success value of the given `Micro` effect with an `Option`,
+ * wrapping the success value in `Some` and returning `None` if the effect fails
+ * with an expected error.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const option: <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, never, R>;
+/**
+ * Replace the success value of the given `Micro` effect with an `Either`,
+ * wrapping the success value in `Right` and wrapping any expected errors with
+ * a `Left`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const either: <A, E, R>(self: Micro<A, E, R>) => Micro<Either.Either<A, E>, never, R>;
+/**
+ * Retry the given `Micro` effect using the provided options.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const retry: {
+    <A, E>(options?: {
+        while?: Predicate<E> | undefined;
+        times?: number | undefined;
+        delay?: DelayFn | undefined;
+    } | undefined): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    <A, E, R>(self: Micro<A, E, R>, options?: {
+        while?: Predicate<E> | undefined;
+        times?: number | undefined;
+        delay?: DelayFn | undefined;
+    } | undefined): Micro<A, E, R>;
+};
+/**
+ * Add a stack trace to any failures that occur in the effect. The trace will be
+ * added to the `traces` field of the `Failure` object.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category error handling
+ */
+export declare const withTrace: {
+    (name: string): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    <A, E, R>(self: Micro<A, E, R>, name: string): Micro<A, E, R>;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category pattern matching
+ */
+export declare const matchFailureMicro: {
+    <E, A2, E2, R2, A, A3, E3, R3>(options: {
+        readonly onFailure: (failure: Failure<E>) => Micro<A2, E2, R2>;
+        readonly onSuccess: (a: A) => Micro<A3, E3, R3>;
+    }): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, E2 | E3, R2 | R3 | R>;
+    <A, E, R, A2, E2, R2, A3, E3, R3>(self: Micro<A, E, R>, options: {
+        readonly onFailure: (failure: Failure<E>) => Micro<A2, E2, R2>;
+        readonly onSuccess: (a: A) => Micro<A3, E3, R3>;
+    }): Micro<A2 | A3, E2 | E3, R2 | R3 | R>;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category pattern matching
+ */
+export declare const matchFailure: {
+    <E, A2, A, A3>(options: {
+        readonly onFailure: (failure: Failure<E>) => A2;
+        readonly onSuccess: (a: A) => A3;
+    }): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, never, R>;
+    <A, E, R, A2, A3>(self: Micro<A, E, R>, options: {
+        readonly onFailure: (failure: Failure<E>) => A2;
+        readonly onSuccess: (a: A) => A3;
+    }): Micro<A2 | A3, never, R>;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category pattern matching
+ */
+export declare const matchMicro: {
+    <E, A2, E2, R2, A, A3, E3, R3>(options: {
+        readonly onFailure: (e: E) => Micro<A2, E2, R2>;
+        readonly onSuccess: (a: A) => Micro<A3, E3, R3>;
+    }): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, E2 | E3, R2 | R3 | R>;
+    <A, E, R, A2, E2, R2, A3, E3, R3>(self: Micro<A, E, R>, options: {
+        readonly onFailure: (e: E) => Micro<A2, E2, R2>;
+        readonly onSuccess: (a: A) => Micro<A3, E3, R3>;
+    }): Micro<A2 | A3, E2 | E3, R2 | R3 | R>;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category pattern matching
+ */
+export declare const match: {
+    <E, A2, A, A3>(options: {
+        readonly onFailure: (error: E) => A2;
+        readonly onSuccess: (value: A) => A3;
+    }): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, never, R>;
+    <A, E, R, A2, A3>(self: Micro<A, E, R>, options: {
+        readonly onFailure: (error: E) => A2;
+        readonly onSuccess: (value: A) => A3;
+    }): Micro<A2 | A3, never, R>;
+};
+/**
+ * Create a `Micro` effect that will sleep for the specified duration.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delays & timeouts
+ */
+export declare const sleep: (millis: number) => Micro<void>;
+/**
+ * Returns an effect that will delay the execution of this effect by the
+ * specified duration.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delays & timeouts
+ */
+export declare const delay: {
+    (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E, R>;
+};
+/**
+ * Returns an effect that will timeout this effect, that will execute the
+ * fallback effect if the timeout elapses before the effect has produced a value.
+ *
+ * If the timeout elapses, the running effect will be safely interrupted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delays & timeouts
+ */
+export declare const timeoutOrElse: {
+    <A2, E2, R2>(options: {
+        readonly duration: number;
+        readonly onTimeout: LazyArg<Micro<A2, E2, R2>>;
+    }): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, options: {
+        readonly duration: number;
+        readonly onTimeout: LazyArg<Micro<A2, E2, R2>>;
+    }): Micro<A | A2, E | E2, R | R2>;
+};
+/**
+ * Returns an effect that will timeout this effect, succeeding with a `None`
+ * if the timeout elapses before the effect has produced a value; and `Some` of
+ * the produced value otherwise.
+ *
+ * If the timeout elapses, the running effect will be safely interrupted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category delays & timeouts
+ */
+export declare const timeout: {
+    (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E, R>;
+    <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<Option.Option<A>, E, R>;
+};
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const MicroScopeTypeId: unique symbol;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export type MicroScopeTypeId = typeof MicroScopeTypeId;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export interface MicroScope {
+    readonly [MicroScopeTypeId]: MicroScopeTypeId;
+    readonly addFinalizer: (finalizer: (result: Result<unknown, unknown>) => Micro<void>) => Micro<void>;
+    readonly fork: Micro<MicroScope.Closeable>;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare namespace MicroScope {
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category resources & finalization
+     */
+    interface Closeable extends MicroScope {
+        readonly close: (result: Result<any, any>) => Micro<void>;
+    }
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const MicroScope: Context.Tag<MicroScope, MicroScope>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const scopeMake: Micro<MicroScope.Closeable>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const scopeUnsafeMake: () => MicroScope.Closeable;
+/**
+ * Access the current `MicroScope`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const scope: Micro<MicroScope, never, MicroScope>;
+/**
+ * Provide a `MicroScope` to an effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const provideScope: {
+    (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, MicroScope>>;
+    <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<A, E, Exclude<R, MicroScope>>;
+};
+/**
+ * Provide a `MicroScope` to the given effect, closing it after the effect has
+ * finished executing.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const scoped: <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, MicroScope>>;
+/**
+ * Create a resource with a cleanup `Micro` effect, ensuring the cleanup is
+ * executed when the `MicroScope` is closed.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const acquireRelease: <A, E, R>(acquire: Micro<A, E, R>, release: (a: A, result: Result<unknown, unknown>) => Micro<void>) => Micro<A, E, R | MicroScope>;
+/**
+ * Add a finalizer to the current `MicroScope`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const addFinalizer: (finalizer: (result: Result<unknown, unknown>) => Micro<void>) => Micro<void, never, MicroScope>;
+/**
+ * When the `Micro` effect is completed, run the given finalizer effect with the
+ * `Result` of the executed effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const onResult: {
+    <A, E, XE, XR>(f: (result: Result<A, E>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, R, XE, XR>(self: Micro<A, E, R>, f: (result: Result<A, E>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+};
+/**
+ * When the `Micro` effect is completed, run the given finalizer effect if it
+ * matches the specified predicate.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const onResultIf: {
+    <A, E, XE, XR, B extends Result<A, E>>(refinement: Refinement<Result<A, E>, B>, f: (result: B) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, XE, XR>(predicate: Predicate<Result<NoInfer<A>, NoInfer<E>>>, f: (result: Result<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, R, XE, XR, B extends Result<A, E>>(self: Micro<A, E, R>, refinement: Refinement<Result<A, E>, B>, f: (result: B) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+    <A, E, R, XE, XR>(self: Micro<A, E, R>, predicate: Predicate<Result<NoInfer<A>, NoInfer<E>>>, f: (result: Result<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+};
+/**
+ * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const ensuring: {
+    <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+};
+/**
+ * When the `Micro` effect fails, run the given finalizer effect with the
+ * `Failure` of the executed effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const onFailure: {
+    <A, E, XE, XR>(f: (failure: Failure<NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, R, XE, XR>(self: Micro<A, E, R>, f: (failure: Failure<NoInfer<E>>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+};
+/**
+ * If this `Micro` effect is aborted, run the finalizer effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const onAbort: {
+    <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
+};
+/**
+ * Acquire a resource, use it, and then release the resource when the `use`
+ * effect has completed.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category resources & finalization
+ */
+export declare const acquireUseRelease: <Resource, E, R, A, E2, R2, E3, R3>(acquire: Micro<Resource, E, R>, use: (a: Resource) => Micro<A, E2, R2>, release: (a: Resource, result: Result<A, E2>) => Micro<void, E3, R3>) => Micro<A, E | E2 | E3, R | R2 | R3>;
+/**
+ * Abort the current `Micro` effect.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
+ */
+export declare const abort: Micro<never>;
+/**
+ * Wrap the given `Micro` effect in an uninterruptible region, preventing the
+ * effect from being aborted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
+ */
+export declare const uninterruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+/**
+ * Wrap the given `Micro` effect in an uninterruptible region, preventing the
+ * effect from being aborted.
+ *
+ * You can use the `restore` function to restore a `Micro` effect to the
+ * interruptibility state before the `uninterruptibleMask` was applied.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
+ * @example
+ * import * as Micro from "effect/Micro"
+ *
+ * Micro.uninterruptibleMask((restore) =>
+ *   Micro.sleep(1000).pipe( // uninterruptible
+ *     Micro.andThen(restore(Micro.sleep(1000))) // interruptible
+ *   )
+ * )
+ */
+export declare const uninterruptibleMask: <A, E, R>(f: (restore: <A_1, E_1, R_1>(effect: Micro<A_1, E_1, R_1>) => Micro<A_1, E_1, R_1>) => Micro<A, E, R>) => Micro<A, E, R>;
+/**
+ * Wrap the given `Micro` effect in an interruptible region, allowing the effect
+ * to be aborted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category interruption
+ */
+export declare const interruptible: <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+/**
+ * @since 3.4.0
+ * @experimental
+ */
+export declare namespace All {
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type MicroAny = Micro<any, any, any>;
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type ReturnIterable<T extends Iterable<MicroAny>, Discard extends boolean> = [T] extends [
+        Iterable<Micro<infer A, infer E, infer R>>
+    ] ? Micro<Discard extends true ? void : Array<A>, E, R> : never;
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type ReturnTuple<T extends ReadonlyArray<unknown>, Discard extends boolean> = Micro<Discard extends true ? void : T[number] extends never ? [] : {
+        -readonly [K in keyof T]: T[K] extends Micro<infer _A, infer _E, infer _R> ? _A : never;
+    }, T[number] extends never ? never : T[number] extends Micro<infer _A, infer _E, infer _R> ? _E : never, T[number] extends never ? never : T[number] extends Micro<infer _A, infer _E, infer _R> ? _R : never> extends infer X ? X : never;
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type ReturnObject<T, Discard extends boolean> = [T] extends [{
+        [K: string]: MicroAny;
+    }] ? Micro<Discard extends true ? void : {
+        -readonly [K in keyof T]: [T[K]] extends [Micro<infer _A, infer _E, infer _R>] ? _A : never;
+    }, keyof T extends never ? never : T[keyof T] extends Micro<infer _A, infer _E, infer _R> ? _E : never, keyof T extends never ? never : T[keyof T] extends Micro<infer _A, infer _E, infer _R> ? _R : never> : never;
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type IsDiscard<A> = [Extract<A, {
+        readonly discard: true;
+    }>] extends [never] ? false : true;
+    /**
+     * @since 3.4.0
+     * @experimental
+     */
+    type Return<Arg extends Iterable<MicroAny> | Record<string, MicroAny>, O extends {
+        readonly concurrency?: Concurrency | undefined;
+        readonly discard?: boolean | undefined;
+    }> = [Arg] extends [ReadonlyArray<MicroAny>] ? ReturnTuple<Arg, IsDiscard<O>> : [Arg] extends [Iterable<MicroAny>] ? ReturnIterable<Arg, IsDiscard<O>> : [Arg] extends [Record<string, MicroAny>] ? ReturnObject<Arg, IsDiscard<O>> : never;
+}
+/**
+ * Runs all the provided effects in sequence respecting the structure provided in input.
+ *
+ * Supports multiple arguments, a single argument tuple / array or record / struct.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category collecting & elements
+ */
+export declare const all: <const Arg extends Iterable<Micro<any, any, any>> | Record<string, Micro<any, any, any>>, O extends {
+    readonly concurrency?: Concurrency | undefined;
+    readonly discard?: boolean | undefined;
+}>(arg: Arg, options?: O) => All.Return<Arg, O>;
+/**
+ * For each element of the provided iterable, run the effect and collect the results.
+ *
+ * If the `discard` option is set to `true`, the results will be discarded and
+ * the effect will return `void`.
+ *
+ * The `concurrency` option can be set to control how many effects are run in
+ * parallel. By default, the effects are run sequentially.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category collecting & elements
+ */
+export declare const forEach: {
+    <A, B, E, R>(iterable: Iterable<A>, f: (a: A, index: number) => Micro<B, E, R>, options?: {
+        readonly concurrency?: Concurrency | undefined;
+        readonly discard?: false | undefined;
+    }): Micro<Array<B>, E, R>;
+    <A, B, E, R>(iterable: Iterable<A>, f: (a: A, index: number) => Micro<B, E, R>, options: {
+        readonly concurrency?: Concurrency | undefined;
+        readonly discard: true;
+    }): Micro<void, E, R>;
+};
+/**
+ * Effectfully filter the elements of the provided iterable.
+ *
+ * Use the `concurrency` option to control how many elements are processed in parallel.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category collecting & elements
+ */
+export declare const filter: <A, E, R>(iterable: Iterable<A>, f: (a: NoInfer<A>) => Micro<boolean, E, R>, options?: {
+    readonly concurrency?: Concurrency | undefined;
+    readonly negate?: boolean | undefined;
+}) => Micro<Array<A>, E, R>;
+/**
+ * Effectfully filter the elements of the provided iterable.
+ *
+ * Use the `concurrency` option to control how many elements are processed in parallel.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category collecting & elements
+ */
+export declare const filterMap: <A, B, E, R>(iterable: Iterable<A>, f: (a: NoInfer<A>) => Micro<Option.Option<B>, E, R>, options?: {
+    readonly concurrency?: Concurrency | undefined;
+}) => Micro<Array<B>, E, R>;
+/**
+ * Start a do notation block.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category do notation
+ */
+export declare const Do: Micro<{}>;
+/**
+ * Bind the success value of this `Micro` effect to the provided name.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category do notation
+ */
+export declare const bindTo: {
+    <N extends string>(name: N): <A, E, R>(self: Micro<A, E, R>) => Micro<{
+        [K in N]: A;
+    }, E, R>;
+    <A, E, R, N extends string>(self: Micro<A, E, R>, name: N): Micro<{
+        [K in N]: A;
+    }, E, R>;
+};
+/**
+ * Bind the success value of this `Micro` effect to the provided name.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category do notation
+ */
+export declare const bind: {
+    <N extends string, A extends Record<string, any>, B, E2, R2>(name: N, f: (a: A) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & {
+        [K in N]: B;
+    }>, E | E2, R | R2>;
+    <A extends Record<string, any>, E, R, B, E2, R2, N extends string>(self: Micro<A, E, R>, name: N, f: (a: A) => Micro<B, E2, R2>): Micro<Simplify<Omit<A, N> & {
+        [K in N]: B;
+    }>, E | E2, R | R2>;
+};
+declare const let_: {
+    <N extends string, A extends Record<string, any>, B>(name: N, f: (a: A) => B): <E, R>(self: Micro<A, E, R>) => Micro<Simplify<Omit<A, N> & {
+        [K in N]: B;
+    }>, E, R>;
+    <A extends Record<string, any>, E, R, B, N extends string>(self: Micro<A, E, R>, name: N, f: (a: A) => B): Micro<Simplify<Omit<A, N> & {
+        [K in N]: B;
+    }>, E, R>;
+};
+export { 
+/**
+ * Bind the result of a synchronous computation to the given name.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category do notation
+ */
+let_ as let };
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+export declare const HandleTypeId: unique symbol;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+export type HandleTypeId = typeof HandleTypeId;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+export interface Handle<A, E = never> {
+    readonly [HandleTypeId]: HandleTypeId;
+    readonly await: Micro<Result<A, E>>;
+    readonly join: Micro<A, E>;
+    readonly abort: Micro<Result<A, E>>;
+    readonly unsafeAbort: () => void;
+    readonly addObserver: (observer: (result: Result<A, E>) => void) => void;
+    readonly removeObserver: (observer: (result: Result<A, E>) => void) => void;
+    readonly unsafePoll: () => Result<A, E> | null;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+export declare const isHandle: (u: unknown) => u is Handle<unknown, unknown>;
+/**
+ * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * aborted.
+ *
+ * When the parent `Micro` finishes, this `Micro` will be aborted.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+export declare const fork: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R>;
+/**
+ * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * aborted.
+ *
+ * It will not be aborted when the parent `Micro` finishes.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+export declare const forkDaemon: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R>;
+/**
+ * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * aborted.
+ *
+ * The lifetime of the handle will be attached to the provided `MicroScope`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+export declare const forkIn: {
+    (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R>;
+    <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Handle<A, E>, never, R>;
+};
+/**
+ * Run the `Micro` effect in a new `Handle` that can be awaited, joined, or
+ * aborted.
+ *
+ * The lifetime of the handle will be attached to the current `MicroScope`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category handle & forking
+ */
+export declare const forkScoped: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle<A, E>, never, R | MicroScope>;
+/**
+ * Execute the `Micro` effect and return a `Handle` that can be awaited, joined,
+ * or aborted.
+ *
+ * You can listen for the result by adding an observer using the handle's
+ * `addObserver` method.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ * @example
+ * import * as Micro from "effect/Micro"
+ *
+ * const handle = Micro.succeed(42).pipe(
+ *   Micro.delay(1000),
+ *   Micro.runFork
+ * )
+ *
+ * handle.addObserver((result) => {
+ *   console.log(result)
+ * })
+ */
+export declare const runFork: <A, E>(effect: Micro<A, E>, options?: {
+    readonly signal?: AbortSignal | undefined;
+} | undefined) => Handle<A, E>;
+/**
+ * Execute the `Micro` effect and return a `Promise` that resolves with the
+ * `Result` of the computation.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ */
+export declare const runPromiseResult: <A, E>(effect: Micro<A, E>, options?: {
+    readonly signal?: AbortSignal | undefined;
+} | undefined) => Promise<Result<A, E>>;
+/**
+ * Execute the `Micro` effect and return a `Promise` that resolves with the
+ * successful value of the computation.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ */
+export declare const runPromise: <A, E>(effect: Micro<A, E>, options?: {
+    readonly signal?: AbortSignal | undefined;
+} | undefined) => Promise<A>;
+/**
+ * Attempt to execute the `Micro` effect synchronously and return the `Result`.
+ *
+ * If any asynchronous effects are encountered, the function will return a
+ * FailureUnexpected containing the `Handle`.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ */
+export declare const runSyncResult: <A, E>(effect: Micro<A, E>) => Result<A, E>;
+/**
+ * Attempt to execute the `Micro` effect synchronously and return the success
+ * value.
+ *
+ * @since 3.4.0
+ * @experimental
+ * @category execution
+ */
+export declare const runSync: <A, E>(effect: Micro<A, E>) => A;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category errors
+ */
+export interface YieldableError extends Pipeable, Inspectable, Readonly<Error> {
+    readonly [EffectTypeId]: Effect.VarianceStruct<never, this, never>;
+    readonly [StreamTypeId]: Stream.VarianceStruct<never, this, never>;
+    readonly [SinkTypeId]: Sink.VarianceStruct<never, unknown, never, this, never>;
+    readonly [ChannelTypeId]: Channel.VarianceStruct<never, unknown, this, unknown, never, unknown, never>;
+    readonly [TypeId]: Micro.Variance<never, this, never>;
+    readonly [runSymbol]: (env: Env<any>, onResult: (result: Result<never, this>) => void) => void;
+    [Symbol.iterator](): MicroIterator<Micro<never, this, never>>;
+}
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category errors
+ */
+export declare const Error: new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : {
+    readonly [P in keyof A]: A[P];
+}) => YieldableError & Readonly<A>;
+/**
+ * @since 3.4.0
+ * @experimental
+ * @category errors
+ */
+export declare const TaggedError: <Tag extends string>(tag: Tag) => new <A extends Record<string, any> = {}>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
+    readonly _tag: Tag;
+} & Readonly<A>;
+//# sourceMappingURL=Micro.d.ts.map