effect 3.8.4 → 3.9.0

package/dist/dts/Micro.d.ts

@@ -272,7 +272,17 @@ export declare const causeSquash: <E>(self: MicroCause<E>) => unknown;
  * @category MicroCause
  */
 export declare const causeWithTrace: {
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category MicroCause
+     */
     (trace: string): <E>(self: MicroCause<E>) => MicroCause<E>;
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category MicroCause
+     */
     <E>(self: MicroCause<E>, trace: string): MicroCause<E>;
 };
 /**
@@ -412,7 +422,17 @@ export declare const envUnsafeMakeEmpty: () => Env<never>;
  * @category environment
  */
 export declare const envGet: {
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <A>(ref: EnvRef<A>): <R>(self: Env<R>) => A;
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <A, R>(self: Env<R>, ref: EnvRef<A>): A;
 };
 /**
@@ -421,7 +441,17 @@ export declare const envGet: {
  * @category environment
  */
 export declare const envSet: {
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <A>(ref: EnvRef<A>, value: A): <R>(self: Env<R>) => Env<R>;
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <A, R>(self: Env<R>, ref: EnvRef<A>, value: A): Env<R>;
 };
 /**
@@ -430,7 +460,17 @@ export declare const envSet: {
  * @category environment
  */
 export declare const envMutate: {
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     (f: (map: Record<string, unknown>) => void): <R>(self: Env<R>) => Env<R>;
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <R>(self: Env<R>, f: (map: Record<string, unknown>) => void): Env<R>;
 };
 /**
@@ -469,7 +509,21 @@ export declare const getEnvRef: <A>(envRef: EnvRef<A>) => Micro<A>;
  * @category environment
  */
 export declare const locally: {
+    /**
+     * Set the value of the given `EnvRef` for the duration of the effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <A>(fiberRef: EnvRef<A>, value: A): <XA, E, R>(self: Micro<XA, E, R>) => Micro<XA, E, R>;
+    /**
+     * Set the value of the given `EnvRef` for the duration of the effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <XA, E, R, A>(self: Micro<XA, E, R>, fiberRef: EnvRef<A>, value: A): Micro<XA, E, R>;
 };
 /**
@@ -488,7 +542,21 @@ export declare const context: <R>() => Micro<Context.Context<R>>;
  * @category environment
  */
 export declare const provideContext: {
+    /**
+     * Merge the given `Context` with the current context.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <XR>(context: Context.Context<XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, XR>>;
+    /**
+     * Merge the given `Context` with the current context.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <A, E, R, XR>(self: Micro<A, E, R>, context: Context.Context<XR>): Micro<A, E, Exclude<R, XR>>;
 };
 /**
@@ -499,7 +567,21 @@ export declare const provideContext: {
  * @category environment
  */
 export declare const provideService: {
+    /**
+     * Add the provided service to the current context.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <I, S>(tag: Context.Tag<I, S>, service: S): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, I>>;
+    /**
+     * Add the provided service to the current context.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category environment
+     */
     <A, E, R, I, S>(self: Micro<A, E, R>, tag: Context.Tag<I, S>, service: S): Micro<A, E, Exclude<R, I>>;
 };
 /**
@@ -511,7 +593,23 @@ export declare const provideService: {
  * @category environment
  */
 export declare const provideServiceEffect: {
+    /**
+     * Create a service using the provided `Micro` effect, and add it to the
+     * current context.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category environment
+     */
     <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>;
+    /**
+     * Create a service using the provided `Micro` effect, and add it to the
+     * current context.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category environment
+     */
     <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>;
 };
 /**
@@ -655,7 +753,39 @@ export declare const currentScheduler: EnvRef<MicroScheduler>;
  * )
  */
 export declare const withConcurrency: {
+    /**
+     * 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
+     * )
+     */
     (concurrency: "unbounded" | number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    /**
+     * 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
+     * )
+     */
     <A, E, R>(self: Micro<A, E, R>, concurrency: "unbounded" | number): Micro<A, E, R>;
 };
 /**
@@ -928,7 +1058,23 @@ export declare const flatten: <A, E, R, E2, R2>(self: Micro<Micro<A, E, R>, E2,
  * @category mapping & sequencing
  */
 export declare const map: {
+    /**
+     * Transforms the success value of the `Micro` effect with the specified
+     * function.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
     <A, B>(f: (a: A) => B): <E, R>(self: Micro<A, E, R>) => Micro<B, E, R>;
+    /**
+     * Transforms the success value of the `Micro` effect with the specified
+     * function.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
     <A, E, R, B>(self: Micro<A, E, R>, f: (a: A) => B): Micro<B, E, R>;
 };
 /**
@@ -940,7 +1086,23 @@ export declare const map: {
  * @category mapping & sequencing
  */
 export declare const as: {
+    /**
+     * Create a `Micro` effect that will replace the success value of the given
+     * effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
     <A, B>(value: B): <E, R>(self: Micro<A, E, R>) => 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
+     */
     <A, E, R, B>(self: Micro<A, E, R>, value: B): Micro<B, E, R>;
 };
 /**
@@ -960,7 +1122,23 @@ export declare const asSome: <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Opt
  * @category mapping & sequencing
  */
 export declare const flatMap: {
+    /**
+     * Map the success value of this `Micro` effect to another `Micro` effect, then
+     * flatten the result.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
     <A, B, E2, R2>(f: (a: A) => Micro<B, E2, R2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E | E2, R | R2>;
+    /**
+     * Map the success value of this `Micro` effect to another `Micro` effect, then
+     * flatten the result.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category mapping & sequencing
+     */
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (a: A) => Micro<B, E2, R2>): Micro<B, E | E2, R | R2>;
 };
 /**
@@ -983,9 +1161,53 @@ export declare const flip: <A, E, R>(self: Micro<A, E, R>) => Micro<E, A, R>;
  * @category mapping & sequencing
  */
 export declare const andThen: {
+    /**
+     * 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
+     */
     <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>;
+    /**
+     * 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
+     */
     <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 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
+     */
     <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 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
+     */
     <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>;
 };
 /**
@@ -998,9 +1220,45 @@ export declare const andThen: {
  * @category mapping & sequencing
  */
 export declare const tap: {
+    /**
+     * 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
+     */
     <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>;
+    /**
+     * 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
+     */
     <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>;
+    /**
+     * 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
+     */
     <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>;
+    /**
+     * 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
+     */
     <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>;
 };
 /**
@@ -1056,7 +1314,23 @@ export declare const raceAllFirst: <Eff extends Micro<any, any, any>>(all: Itera
  * @category sequencing
  */
 export declare const race: {
+    /**
+     * 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
+     */
     <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | A2, E | E2, R | R2>;
+    /**
+     * 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
+     */
     <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
 };
 /**
@@ -1068,7 +1342,23 @@ export declare const race: {
  * @category sequencing
  */
 export declare const raceFirst: {
+    /**
+     * 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
+     */
     <A2, E2, R2>(that: Micro<A2, E2, R2>): <A, E, R>(self: Micro<A, E, R>) => 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
+     */
     <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
 };
 /**
@@ -1080,9 +1370,25 @@ export declare const raceFirst: {
  * @category zipping
  */
 export declare const zip: {
+    /**
+     * Combine two `Micro` effects into a single effect that produces a tuple of
+     * their results.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category zipping
+     */
     <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>;
+    /**
+     * Combine two `Micro` effects into a single effect that produces a tuple of
+     * their results.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category zipping
+     */
     <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>, options?: {
         readonly concurrent?: boolean | undefined;
     }): Micro<[A, A2], E | E2, R | R2>;
@@ -1097,9 +1403,27 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipWith: {
+    /**
+     * The `Micro.zipWith` function combines two `Micro` effects and allows you to
+     * apply a function to the results of the combined effects, transforming them
+     * into a single value.
+     *
+     * @since 3.4.3
+     * @experimental
+     * @category zipping
+     */
     <A2, E2, R2, A, B>(that: Micro<A2, E2, R2>, f: (a: A, b: A2) => B, options?: {
         readonly concurrent?: boolean | undefined;
     }): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R2 | R>;
+    /**
+     * The `Micro.zipWith` function combines two `Micro` effects and allows you to
+     * apply a function to the results of the combined effects, transforming them
+     * into a single value.
+     *
+     * @since 3.4.3
+     * @experimental
+     * @category zipping
+     */
     <A, E, R, A2, E2, R2, B>(self: Micro<A, E, R>, that: Micro<A2, E2, R2>, f: (a: A, b: A2) => B, options?: {
         readonly concurrent?: boolean | undefined;
     }): Micro<B, E2 | E, R2 | R>;
@@ -1116,9 +1440,53 @@ export declare const zipWith: {
  * @category filtering & conditionals
  */
 export declare const filterOrFailCause: {
+    /**
+     * Filter the specified effect with the provided function, failing with specified
+     * `MicroCause` 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
+     */
     <A, B extends A, E2>(refinement: Refinement<A, B>, orFailWith: (a: NoInfer<A>) => MicroCause<E2>): <E, R>(self: Micro<A, E, R>) => Micro<B, E2 | E, R>;
+    /**
+     * Filter the specified effect with the provided function, failing with specified
+     * `MicroCause` 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
+     */
     <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => MicroCause<E2>): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, R>;
+    /**
+     * Filter the specified effect with the provided function, failing with specified
+     * `MicroCause` 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
+     */
     <A, E, R, B extends A, E2>(self: Micro<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => MicroCause<E2>): Micro<B, E | E2, R>;
+    /**
+     * Filter the specified effect with the provided function, failing with specified
+     * `MicroCause` 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
+     */
     <A, E, R, E2>(self: Micro<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => MicroCause<E2>): Micro<A, E | E2, R>;
 };
 /**
@@ -1133,9 +1501,53 @@ export declare const filterOrFailCause: {
  * @category filtering & conditionals
  */
 export declare const filterOrFail: {
+    /**
+     * 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
+     */
     <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>;
+    /**
+     * 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
+     */
     <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: Micro<A, E, R>) => Micro<A, E2 | E, 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
+     */
     <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>;
+    /**
+     * 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
+     */
     <A, E, R, E2>(self: Micro<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): Micro<A, E | E2, R>;
 };
 /**
@@ -1146,7 +1558,21 @@ export declare const filterOrFail: {
  * @category filtering & conditionals
  */
 export declare const when: {
+    /**
+     * The moral equivalent of `if (p) exp`.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category filtering & conditionals
+     */
     <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>;
+    /**
+     * The moral equivalent of `if (p) exp`.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category filtering & conditionals
+     */
     <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>;
 };
 /**
@@ -1160,11 +1586,31 @@ export declare const when: {
  * @category repetition
  */
 export declare const repeatExit: {
+    /**
+     * Repeat the given `Micro` using the provided options.
+     *
+     * The `while` predicate will be checked after each iteration, and can use the
+     * fall `MicroExit` of the effect to determine if the repetition should continue.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category repetition
+     */
     <A, E>(options: {
         while: Predicate<MicroExit<A, E>>;
         times?: number | undefined;
         schedule?: MicroSchedule | undefined;
     }): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    /**
+     * Repeat the given `Micro` using the provided options.
+     *
+     * The `while` predicate will be checked after each iteration, and can use the
+     * fall `MicroExit` of the effect to determine if the repetition should continue.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category repetition
+     */
     <A, E, R>(self: Micro<A, E, R>, options: {
         while: Predicate<MicroExit<A, E>>;
         times?: number | undefined;
@@ -1180,11 +1626,27 @@ export declare const repeatExit: {
  * @category repetition
  */
 export declare const repeat: {
+    /**
+     * Repeat the given `Micro` effect using the provided options. Only successful
+     * results will be repeated.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category repetition
+     */
     <A, E>(options?: {
         while?: Predicate<A> | undefined;
         times?: number | undefined;
         schedule?: MicroSchedule | undefined;
     } | undefined): <R>(self: Micro<A, E, R>) => 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
+     */
     <A, E, R>(self: Micro<A, E, R>, options?: {
         while?: Predicate<A> | undefined;
         times?: number | undefined;
@@ -1246,7 +1708,23 @@ export declare const scheduleExponential: (baseMillis: number, factor?: number)
  * @category scheduling
  */
 export declare const scheduleAddDelay: {
+    /**
+     * Returns a new `MicroSchedule` with an added calculated delay to each delay
+     * returned by this schedule.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (f: () => number): (self: MicroSchedule) => MicroSchedule;
+    /**
+     * Returns a new `MicroSchedule` with an added calculated delay to each delay
+     * returned by this schedule.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (self: MicroSchedule, f: () => number): MicroSchedule;
 };
 /**
@@ -1258,7 +1736,23 @@ export declare const scheduleAddDelay: {
  * @category scheduling
  */
 export declare const scheduleWithMaxDelay: {
+    /**
+     * Transform a `MicroSchedule` to one that will have a delay that will never exceed
+     * the specified maximum.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (max: number): (self: MicroSchedule) => MicroSchedule;
+    /**
+     * Transform a `MicroSchedule` to one that will have a delay that will never exceed
+     * the specified maximum.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (self: MicroSchedule, max: number): MicroSchedule;
 };
 /**
@@ -1270,7 +1764,23 @@ export declare const scheduleWithMaxDelay: {
  * @category scheduling
  */
 export declare const scheduleWithMaxElapsed: {
+    /**
+     * Transform a `MicroSchedule` to one that will stop repeating after the specified
+     * amount of time.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (max: number): (self: MicroSchedule) => MicroSchedule;
+    /**
+     * Transform a `MicroSchedule` to one that will stop repeating after the specified
+     * amount of time.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (self: MicroSchedule, max: number): MicroSchedule;
 };
 /**
@@ -1282,7 +1792,23 @@ export declare const scheduleWithMaxElapsed: {
  * @category scheduling
  */
 export declare const scheduleUnion: {
+    /**
+     * Combines two `MicroSchedule`s, by recurring if either schedule wants to
+     * recur, using the minimum of the two durations between recurrences.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (that: MicroSchedule): (self: MicroSchedule) => MicroSchedule;
+    /**
+     * Combines two `MicroSchedule`s, by recurring if either schedule wants to
+     * recur, using the minimum of the two durations between recurrences.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (self: MicroSchedule, that: MicroSchedule): MicroSchedule;
 };
 /**
@@ -1294,7 +1820,23 @@ export declare const scheduleUnion: {
  * @category scheduling
  */
 export declare const scheduleIntersect: {
+    /**
+     * Combines two `MicroSchedule`s, by recurring only if both schedules want to
+     * recur, using the maximum of the two durations between recurrences.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (that: MicroSchedule): (self: MicroSchedule) => MicroSchedule;
+    /**
+     * Combines two `MicroSchedule`s, by recurring only if both schedules want to
+     * recur, using the maximum of the two durations between recurrences.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category scheduling
+     */
     (self: MicroSchedule, that: MicroSchedule): MicroSchedule;
 };
 /**
@@ -1306,7 +1848,23 @@ export declare const scheduleIntersect: {
  * @category error handling
  */
 export declare const catchAllCause: {
+    /**
+     * Catch the full `MicroCause` object of the given `Micro` effect, allowing you to
+     * recover from any kind of cause.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <E, B, E2, R2>(f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E2, R | R2>;
+    /**
+     * Catch the full `MicroCause` object of the given `Micro` effect, allowing you to
+     * recover from any kind of cause.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A | B, E2, R | R2>;
 };
 /**
@@ -1318,9 +1876,41 @@ export declare const catchAllCause: {
  * @category error handling
  */
 export declare const catchCauseIf: {
+    /**
+     * Selectively catch a `MicroCause` object of the given `Micro` effect,
+     * using the provided predicate to determine if the failure should be caught.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <E, B, E2, R2, EB extends MicroCause<E>>(refinement: Refinement<MicroCause<E>, EB>, f: (cause: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, Exclude<E, MicroCause.Error<EB>> | E2, R | R2>;
+    /**
+     * Selectively catch a `MicroCause` object of the given `Micro` effect,
+     * using the provided predicate to determine if the failure should be caught.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <E, B, E2, R2>(predicate: Predicate<MicroCause<NoInfer<E>>>, f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A | B, E | E2, R | R2>;
+    /**
+     * Selectively catch a `MicroCause` object of the given `Micro` effect,
+     * using the provided predicate to determine if the failure should be caught.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B, E2, R2, EB extends MicroCause<E>>(self: Micro<A, E, R>, refinement: Refinement<MicroCause<E>, EB>, f: (cause: EB) => Micro<B, E2, R2>): Micro<A | B, Exclude<E, MicroCause.Error<EB>> | E2, R | R2>;
+    /**
+     * Selectively catch a `MicroCause` object of the given `Micro` effect,
+     * using the provided predicate to determine if the failure should be caught.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: Predicate<MicroCause<NoInfer<E>>>, f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A | B, E | E2, R | R2>;
 };
 /**
@@ -1333,7 +1923,25 @@ export declare const catchCauseIf: {
  * @category error handling
  */
 export declare const catchAll: {
+    /**
+     * Catch the error of the given `Micro` effect, allowing you to recover from it.
+     *
+     * It only catches expected (`MicroCause.Fail`) errors.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <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>;
+    /**
+     * Catch the error of the given `Micro` effect, allowing you to recover from it.
+     *
+     * It only catches expected (`MicroCause.Fail`) errors.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <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>;
 };
 /**
@@ -1344,7 +1952,21 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare const catchAllDefect: {
+    /**
+     * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <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>;
+    /**
+     * Catch any unexpected errors of the given `Micro` effect, allowing you to recover from them.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <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>;
 };
 /**
@@ -1355,7 +1977,21 @@ export declare const catchAllDefect: {
  * @category error handling
  */
 export declare const tapErrorCause: {
+    /**
+     * Perform a side effect using the full `MicroCause` object of the given `Micro`.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <E, B, E2, R2>(f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    /**
+     * Perform a side effect using the full `MicroCause` object of the given `Micro`.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (cause: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
 };
 /**
@@ -1367,9 +2003,41 @@ export declare const tapErrorCause: {
  * @category error handling
  */
 export declare const tapErrorCauseIf: {
+    /**
+     * Perform a side effect using if a `MicroCause` object matches the specified
+     * predicate.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <E, B, E2, R2, EB extends MicroCause<E>>(refinement: Refinement<MicroCause<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    /**
+     * Perform a side effect using if a `MicroCause` object matches the specified
+     * predicate.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <E, B, E2, R2>(predicate: (cause: NoInfer<MicroCause<E>>) => boolean, f: (a: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    /**
+     * Perform a side effect using if a `MicroCause` object matches the specified
+     * predicate.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B, E2, R2, EB extends MicroCause<E>>(self: Micro<A, E, R>, refinement: Refinement<MicroCause<E>, EB>, f: (a: EB) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
+    /**
+     * Perform a side effect using if a `MicroCause` object matches the specified
+     * predicate.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, predicate: (cause: NoInfer<MicroCause<E>>) => boolean, f: (a: NoInfer<MicroCause<E>>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
 };
 /**
@@ -1380,7 +2048,21 @@ export declare const tapErrorCauseIf: {
  * @category error handling
  */
 export declare const tapError: {
+    /**
+     * Perform a side effect from expected errors of the given `Micro`.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <E, B, E2, R2>(f: (e: NoInfer<E>) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    /**
+     * Perform a side effect from expected errors of the given `Micro`.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (e: NoInfer<E>) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
 };
 /**
@@ -1391,7 +2073,21 @@ export declare const tapError: {
  * @category error handling
  */
 export declare const tapDefect: {
+    /**
+     * Perform a side effect from unexpected errors of the given `Micro`.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <E, B, E2, R2>(f: (defect: unknown) => Micro<B, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E | E2, R | R2>;
+    /**
+     * Perform a side effect from unexpected errors of the given `Micro`.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B, E2, R2>(self: Micro<A, E, R>, f: (defect: unknown) => Micro<B, E2, R2>): Micro<A, E | E2, R | R2>;
 };
 /**
@@ -1402,9 +2098,37 @@ export declare const tapDefect: {
  * @category error handling
  */
 export declare const catchIf: {
+    /**
+     * Catch any expected errors that match the specified predicate.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <E, EB extends E, A2, E2, R2>(refinement: Refinement<NoInfer<E>, EB>, f: (e: EB) => Micro<A2, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E2 | Exclude<E, EB>, R2 | R>;
+    /**
+     * Catch any expected errors that match the specified predicate.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <E, A2, E2, R2>(predicate: Predicate<NoInfer<E>>, f: (e: NoInfer<E>) => Micro<A2, E2, R2>): <A, R>(self: Micro<A, E, R>) => Micro<A2 | A, E | E2, R2 | R>;
+    /**
+     * Catch any expected errors that match the specified predicate.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, EB extends E, A2, E2, R2>(self: Micro<A, E, R>, refinement: Refinement<E, EB>, f: (e: EB) => Micro<A2, E2, R2>): Micro<A | A2, E2 | Exclude<E, EB>, R | R2>;
+    /**
+     * Catch any expected errors that match the specified predicate.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, predicate: Predicate<E>, f: (e: E) => Micro<A2, E2, R2>): Micro<A | A2, E | E2, R | R2>;
 };
 /**
@@ -1415,6 +2139,13 @@ export declare const catchIf: {
  * @category error handling
  */
 export declare const catchTag: {
+    /**
+     * Recovers from the specified tagged error.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <K extends E extends {
         _tag: string;
     } ? E["_tag"] : never, E, A1, E1, R1>(k: K, f: (e: Extract<E, {
@@ -1422,6 +2153,13 @@ export declare const catchTag: {
     }>) => Micro<A1, E1, R1>): <A, R>(self: Micro<A, E, R>) => Micro<A1 | A, E1 | Exclude<E, {
         _tag: K;
     }>, R1 | R>;
+    /**
+     * Recovers from the specified tagged error.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <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, {
@@ -1438,7 +2176,21 @@ export declare const catchTag: {
  * @category error handling
  */
 export declare const mapErrorCause: {
+    /**
+     * Transform the full `MicroCause` object of the given `Micro` effect.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <E, E2>(f: (e: MicroCause<E>) => MicroCause<E2>): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>;
+    /**
+     * Transform the full `MicroCause` object of the given `Micro` effect.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, E2>(self: Micro<A, E, R>, f: (e: MicroCause<E>) => MicroCause<E2>): Micro<A, E2, R>;
 };
 /**
@@ -1449,7 +2201,21 @@ export declare const mapErrorCause: {
  * @category error handling
  */
 export declare const mapError: {
+    /**
+     * Transform any expected errors of the given `Micro` effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <E, E2>(f: (e: E) => E2): <A, R>(self: Micro<A, E, R>) => Micro<A, E2, R>;
+    /**
+     * Transform any expected errors of the given `Micro` effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, E2>(self: Micro<A, E, R>, f: (e: E) => E2): Micro<A, E2, R>;
 };
 /**
@@ -1469,7 +2235,21 @@ export declare const orDie: <A, E, R>(self: Micro<A, E, R>) => Micro<A, never, R
  * @category error handling
  */
 export declare const orElseSucceed: {
+    /**
+     * Recover from all errors by succeeding with the given value.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <B>(f: LazyArg<B>): <A, E, R>(self: Micro<A, E, R>) => Micro<A | B, never, R>;
+    /**
+     * Recover from all errors by succeeding with the given value.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E, R, B>(self: Micro<A, E, R>, f: LazyArg<B>): Micro<A | B, never, R>;
 };
 /**
@@ -1516,11 +2296,25 @@ export declare const either: <A, E, R>(self: Micro<A, E, R>) => Micro<Either.Eit
  * @category error handling
  */
 export declare const retry: {
+    /**
+     * Retry the given `Micro` effect using the provided options.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E>(options?: {
         while?: Predicate<E> | undefined;
         times?: number | undefined;
         schedule?: MicroSchedule | undefined;
     } | undefined): <R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    /**
+     * Retry the given `Micro` effect using the provided options.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E, R>(self: Micro<A, E, R>, options?: {
         while?: Predicate<E> | undefined;
         times?: number | undefined;
@@ -1536,7 +2330,23 @@ export declare const retry: {
  * @category error handling
  */
 export declare const withTrace: {
+    /**
+     * Add a stack trace to any failures that occur in the effect. The trace will be
+     * added to the `traces` field of the `MicroCause` object.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     (name: string): <A, E, R>(self: Micro<A, E, R>) => 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 `MicroCause` object.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category error handling
+     */
     <A, E, R>(self: Micro<A, E, R>, name: string): Micro<A, E, R>;
 };
 /**
@@ -1545,10 +2355,20 @@ export declare const withTrace: {
  * @category pattern matching
  */
 export declare const matchCauseEffect: {
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category pattern matching
+     */
     <E, A2, E2, R2, A, A3, E3, R3>(options: {
         readonly onFailure: (cause: MicroCause<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>;
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category pattern matching
+     */
     <A, E, R, A2, E2, R2, A3, E3, R3>(self: Micro<A, E, R>, options: {
         readonly onFailure: (cause: MicroCause<E>) => Micro<A2, E2, R2>;
         readonly onSuccess: (a: A) => Micro<A3, E3, R3>;
@@ -1560,10 +2380,20 @@ export declare const matchCauseEffect: {
  * @category pattern matching
  */
 export declare const matchCause: {
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category pattern matching
+     */
     <E, A2, A, A3>(options: {
         readonly onFailure: (cause: MicroCause<E>) => A2;
         readonly onSuccess: (a: A) => A3;
     }): <R>(self: Micro<A, E, R>) => Micro<A2 | A3, never, R>;
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category pattern matching
+     */
     <A, E, R, A2, A3>(self: Micro<A, E, R>, options: {
         readonly onFailure: (cause: MicroCause<E>) => A2;
         readonly onSuccess: (a: A) => A3;
@@ -1575,10 +2405,20 @@ export declare const matchCause: {
  * @category pattern matching
  */
 export declare const matchEffect: {
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category pattern matching
+     */
     <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>;
+    /**
+     * @since 3.4.6
+     * @experimental
+     * @category pattern matching
+     */
     <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>;
@@ -1590,10 +2430,20 @@ export declare const matchEffect: {
  * @category pattern matching
  */
 export declare const match: {
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category pattern matching
+     */
     <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>;
+    /**
+     * @since 3.4.0
+     * @experimental
+     * @category pattern matching
+     */
     <A, E, R, A2, A3>(self: Micro<A, E, R>, options: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
@@ -1616,7 +2466,23 @@ export declare const sleep: (millis: number) => Micro<void>;
  * @category delays & timeouts
  */
 export declare const delay: {
+    /**
+     * Returns an effect that will delay the execution of this effect by the
+     * specified duration.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category delays & timeouts
+     */
     (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, R>;
+    /**
+     * Returns an effect that will delay the execution of this effect by the
+     * specified duration.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category delays & timeouts
+     */
     <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E, R>;
 };
 /**
@@ -1630,10 +2496,30 @@ export declare const delay: {
  * @category delays & timeouts
  */
 export declare const timeoutOrElse: {
+    /**
+     * 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
+     */
     <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>;
+    /**
+     * 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
+     */
     <A, E, R, A2, E2, R2>(self: Micro<A, E, R>, options: {
         readonly duration: number;
         readonly onTimeout: LazyArg<Micro<A2, E2, R2>>;
@@ -1651,7 +2537,29 @@ export declare const timeoutOrElse: {
  * @category delays & timeouts
  */
 export declare const timeout: {
+    /**
+     * Returns an effect that will timeout this effect, that will fail with a
+     * `TimeoutException` 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
+     */
     (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | TimeoutException, R>;
+    /**
+     * Returns an effect that will timeout this effect, that will fail with a
+     * `TimeoutException` 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
+     */
     <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<A, E | TimeoutException, R>;
 };
 /**
@@ -1666,7 +2574,29 @@ export declare const timeout: {
  * @category delays & timeouts
  */
 export declare const timeoutOption: {
+    /**
+     * 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
+     */
     (millis: number): <A, E, R>(self: Micro<A, E, R>) => Micro<Option.Option<A>, E, R>;
+    /**
+     * 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
+     */
     <A, E, R>(self: Micro<A, E, R>, millis: number): Micro<Option.Option<A>, E, R>;
 };
 /**
@@ -1740,7 +2670,21 @@ export declare const scope: Micro<MicroScope, never, MicroScope>;
  * @category resources & finalization
  */
 export declare const provideScope: {
+    /**
+     * Provide a `MicroScope` to an effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category resources & finalization
+     */
     (scope: MicroScope): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E, Exclude<R, MicroScope>>;
+    /**
+     * Provide a `MicroScope` to an effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<A, E, Exclude<R, MicroScope>>;
 };
 /**
@@ -1778,7 +2722,23 @@ export declare const addFinalizer: (finalizer: (exit: MicroExit<unknown, unknown
  * @category resources & finalization
  */
 export declare const onExit: {
+    /**
+     * When the `Micro` effect is completed, run the given finalizer effect with the
+     * `MicroExit` of the executed effect.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, XE, XR>(f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    /**
+     * When the `Micro` effect is completed, run the given finalizer effect with the
+     * `MicroExit` of the executed effect.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, R, XE, XR>(self: Micro<A, E, R>, f: (exit: MicroExit<A, E>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
 /**
@@ -1790,9 +2750,41 @@ export declare const onExit: {
  * @category resources & finalization
  */
 export declare const onExitIf: {
+    /**
+     * When the `Micro` effect is completed, run the given finalizer effect if it
+     * matches the specified predicate.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, XE, XR, B extends MicroExit<A, E>>(refinement: Refinement<MicroExit<A, E>, B>, f: (exit: B) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => 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.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, XE, XR>(predicate: Predicate<MicroExit<NoInfer<A>, NoInfer<E>>>, f: (exit: MicroExit<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => 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.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, R, XE, XR, B extends MicroExit<A, E>>(self: Micro<A, E, R>, refinement: Refinement<MicroExit<A, E>, B>, f: (exit: B) => 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.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, R, XE, XR>(self: Micro<A, E, R>, predicate: Predicate<MicroExit<NoInfer<A>, NoInfer<E>>>, f: (exit: MicroExit<NoInfer<A>, NoInfer<E>>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
 /**
@@ -1803,7 +2795,21 @@ export declare const onExitIf: {
  * @category resources & finalization
  */
 export declare const ensuring: {
+    /**
+     * Regardless of the result of the this `Micro` effect, run the finalizer effect.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category resources & finalization
+     */
     <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => 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
+     */
     <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
 /**
@@ -1815,7 +2821,23 @@ export declare const ensuring: {
  * @category resources & finalization
  */
 export declare const onError: {
+    /**
+     * When the `Micro` effect fails, run the given finalizer effect with the
+     * `MicroCause` of the executed effect.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, XE, XR>(f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>): <R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    /**
+     * When the `Micro` effect fails, run the given finalizer effect with the
+     * `MicroCause` of the executed effect.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, R, XE, XR>(self: Micro<A, E, R>, f: (cause: MicroCause<NoInfer<E>>) => Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
 /**
@@ -1826,7 +2848,21 @@ export declare const onError: {
  * @category resources & finalization
  */
 export declare const onInterrupt: {
+    /**
+     * If this `Micro` effect is aborted, run the finalizer effect.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category resources & finalization
+     */
     <XE, XR>(finalizer: Micro<void, XE, XR>): <A, E, R>(self: Micro<A, E, R>) => Micro<A, E | XE, R | XR>;
+    /**
+     * If this `Micro` effect is aborted, run the finalizer effect.
+     *
+     * @since 3.4.6
+     * @experimental
+     * @category resources & finalization
+     */
     <A, E, R, XE, XR>(self: Micro<A, E, R>, finalizer: Micro<void, XE, XR>): Micro<A, E | XE, R | XR>;
 };
 /**
@@ -1960,10 +2996,36 @@ export declare const all: <const Arg extends Iterable<Micro<any, any, any>> | Re
  * @category collecting & elements
  */
 export declare const forEach: {
+    /**
+     * 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
+     */
     <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>;
+    /**
+     * 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
+     */
     <A, B, E, R>(iterable: Iterable<A>, f: (a: A, index: number) => Micro<B, E, R>, options: {
         readonly concurrency?: Concurrency | undefined;
         readonly discard: true;
@@ -2010,9 +3072,23 @@ export declare const Do: Micro<{}>;
  * @category do notation
  */
 export declare const bindTo: {
+    /**
+     * Bind the success value of this `Micro` effect to the provided name.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category do notation
+     */
     <N extends string>(name: N): <A, E, R>(self: Micro<A, E, R>) => 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
+     */
     <A, E, R, N extends string>(self: Micro<A, E, R>, name: N): Micro<{
         [K in N]: A;
     }, E, R>;
@@ -2025,9 +3101,23 @@ export declare const bindTo: {
  * @category do notation
  */
 export declare const bind: {
+    /**
+     * Bind the success value of this `Micro` effect to the provided name.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category do notation
+     */
     <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>;
+    /**
+     * Bind the success value of this `Micro` effect to the provided name.
+     *
+     * @since 3.4.0
+     * @experimental
+     * @category do notation
+     */
     <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>;
@@ -2136,7 +3226,27 @@ export declare const forkDaemon: <A, E, R>(self: Micro<A, E, R>) => Micro<Handle
  * @category handle & forking
  */
 export declare const forkIn: {
+    /**
+     * 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
+     */
     (scope: MicroScope): <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
+     */
     <A, E, R>(self: Micro<A, E, R>, scope: MicroScope): Micro<Handle<A, E>, never, R>;
 };
 /**