effect 3.8.4 → 3.9.0

package/dist/dts/STM.d.ts

@@ -155,7 +155,25 @@ export declare const isSTM: (u: unknown) => u is STM<unknown, unknown, unknown>;
  * @category constructors
  */
 export declare const acquireUseRelease: {
+    /**
+     * Treats the specified `acquire` transaction as the acquisition of a
+     * resource. The `acquire` transaction will be executed interruptibly. If it
+     * is a success and is committed the specified `release` workflow will be
+     * executed uninterruptibly as soon as the `use` workflow completes execution.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, A2, E2, R2, A3, E3, R3>(use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): <E, R>(acquire: STM<A, E, R>) => Effect.Effect<A2, E2 | E3 | E, R2 | R3 | R>;
+    /**
+     * Treats the specified `acquire` transaction as the acquisition of a
+     * resource. The `acquire` transaction will be executed interruptibly. If it
+     * is a success and is committed the specified `release` workflow will be
+     * executed uninterruptibly as soon as the `use` workflow completes execution.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, E, R, A2, E2, R2, A3, E3, R3>(acquire: STM<A, E, R>, use: (resource: A) => STM<A2, E2, R2>, release: (resource: A) => STM<A3, E3, R3>): Effect.Effect<A2, E | E2 | E3, R | R2 | R3>;
 };
 /**
@@ -226,7 +244,19 @@ export declare const all: All.Signature;
  * @category mapping
  */
 export declare const as: {
+    /**
+     * Maps the success value of this effect to the specified constant value.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A2>(value: A2): <A, E, R>(self: STM<A, E, R>) => STM<A2, E, R>;
+    /**
+     * Maps the success value of this effect to the specified constant value.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, E, R, A2>(self: STM<A, E, R>, value: A2): STM<A2, E, R>;
 };
 /**
@@ -266,7 +296,19 @@ export declare const attempt: <A>(evaluate: LazyArg<A>) => STM<A, unknown>;
  * @category error handling
  */
 export declare const catchAll: {
+    /**
+     * Recovers from all errors.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <E, B, E1, R1>(f: (e: E) => STM<B, E1, R1>): <A, R>(self: STM<A, E, R>) => STM<B | A, E1, R1 | R>;
+    /**
+     * Recovers from all errors.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R, B, E1, R1>(self: STM<A, E, R>, f: (e: E) => STM<B, E1, R1>): STM<A | B, E1, R | R1>;
 };
 /**
@@ -276,7 +318,19 @@ export declare const catchAll: {
  * @category error handling
  */
 export declare const catchSome: {
+    /**
+     * Recovers from some or all of the error cases.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <E, A2, E2, R2>(pf: (error: E) => Option.Option<STM<A2, E2, R2>>): <A, R>(self: STM<A, E, R>) => STM<A2 | A, E | E2, R2 | R>;
+    /**
+     * Recovers from some or all of the error cases.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R, A2, E2, R2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<STM<A2, E2, R2>>): STM<A | A2, E | E2, R | R2>;
 };
 /**
@@ -286,6 +340,12 @@ export declare const catchSome: {
  * @category error handling
  */
 export declare const catchTag: {
+    /**
+     * Recovers from the specified tagged error.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <K extends E["_tag"] & string, E extends {
         _tag: string;
     }, A1, E1, R1>(k: K, f: (e: Extract<E, {
@@ -293,6 +353,12 @@ export declare const catchTag: {
     }>) => STM<A1, E1, R1>): <A, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | Exclude<E, {
         _tag: K;
     }>, R1 | R>;
+    /**
+     * Recovers from the specified tagged error.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E extends {
         _tag: string;
     }, R, K extends E["_tag"] & string, A1, E1, R1>(self: STM<A, E, R>, k: K, f: (e: Extract<E, {
@@ -308,6 +374,12 @@ export declare const catchTag: {
  * @category error handling
  */
 export declare const catchTags: {
+    /**
+     * Recovers from multiple tagged errors.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <E extends {
         _tag: string;
     }, Cases extends {
@@ -323,6 +395,12 @@ export declare const catchTags: {
     }[keyof Cases], R | {
         [K in keyof Cases]: Cases[K] extends (...args: Array<any>) => STM<any, any, infer R> ? R : never;
     }[keyof Cases]>;
+    /**
+     * Recovers from multiple tagged errors.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <R, E extends {
         _tag: string;
     }, A, Cases extends {
@@ -353,7 +431,19 @@ export declare const check: (predicate: LazyArg<boolean>) => STM<void>;
  * @category mutations
  */
 export declare const collect: {
+    /**
+     * Simultaneously filters and maps the value produced by this effect.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, A2>(pf: (a: A) => Option.Option<A2>): <E, R>(self: STM<A, E, R>) => STM<A2, E, R>;
+    /**
+     * Simultaneously filters and maps the value produced by this effect.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, A2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<A2>): STM<A2, E, R>;
 };
 /**
@@ -363,7 +453,19 @@ export declare const collect: {
  * @category mutations
  */
 export declare const collectSTM: {
+    /**
+     * Simultaneously filters and maps the value produced by this effect.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, A2, E2, R2>(pf: (a: A) => Option.Option<STM<A2, E2, R2>>): <E, R>(self: STM<A, E, R>) => STM<A2, E2 | E, R2 | R>;
+    /**
+     * Simultaneously filters and maps the value produced by this effect.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, A2, E2, R2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<STM<A2, E2, R2>>): STM<A2, E | E2, R | R2>;
 };
 /**
@@ -418,7 +520,21 @@ export declare const contextWithSTM: <R0, A, E, R>(f: (environment: Context.Cont
  * @category context
  */
 export declare const mapInputContext: {
+    /**
+     * Transforms the environment being provided to this effect with the specified
+     * function.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <R0, R>(f: (context: Context.Context<R0>) => Context.Context<R>): <A, E>(self: STM<A, E, R>) => STM<A, E, R0>;
+    /**
+     * Transforms the environment being provided to this effect with the specified
+     * function.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <A, E, R0, R>(self: STM<A, E, R>, f: (context: Context.Context<R0>) => Context.Context<R>): STM<A, E, R0>;
 };
 /**
@@ -459,7 +575,23 @@ export declare const either: <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<
  * @category finalization
  */
 export declare const ensuring: {
+    /**
+     * Executes the specified finalization transaction whether or not this effect
+     * succeeds. Note that as with all STM transactions, if the full transaction
+     * fails, everything will be rolled back.
+     *
+     * @since 2.0.0
+     * @category finalization
+     */
     <R1, B>(finalizer: STM<B, never, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E, R1 | R>;
+    /**
+     * Executes the specified finalization transaction whether or not this effect
+     * succeeds. Note that as with all STM transactions, if the full transaction
+     * fails, everything will be rolled back.
+     *
+     * @since 2.0.0
+     * @category finalization
+     */
     <A, E, R, R1, B>(self: STM<A, E, R>, finalizer: STM<B, never, R1>): STM<A, E, R | R1>;
 };
 /**
@@ -478,7 +610,21 @@ export declare const eventually: <A, E, R>(self: STM<A, E, R>) => STM<A, E, R>;
  * @category constructors
  */
 export declare const every: {
+    /**
+     * Determines whether all elements of the `Iterable<A>` satisfy the effectual
+     * predicate.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<boolean, E, R>;
+    /**
+     * Determines whether all elements of the `Iterable<A>` satisfy the effectual
+     * predicate.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<boolean, E, R>;
 };
 /**
@@ -489,7 +635,21 @@ export declare const every: {
  * @category constructors
  */
 export declare const exists: {
+    /**
+     * Determines whether any element of the `Iterable[A]` satisfies the effectual
+     * predicate `f`.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<boolean, E, R>;
+    /**
+     * Determines whether any element of the `Iterable[A]` satisfies the effectual
+     * predicate `f`.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<boolean, E, R>;
 };
 /**
@@ -520,7 +680,19 @@ export declare const fiberId: STM<FiberId.FiberId>;
  * @category constructors
  */
 export declare const filter: {
+    /**
+     * Filters the collection using the specified effectual predicate.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<Array<A>, E, R>;
+    /**
+     * Filters the collection using the specified effectual predicate.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<Array<A>, E, R>;
 };
 /**
@@ -531,7 +703,21 @@ export declare const filter: {
  * @category constructors
  */
 export declare const filterNot: {
+    /**
+     * Filters the collection using the specified effectual predicate, removing
+     * all elements that satisfy the predicate.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, R, E>(predicate: (a: NoInfer<A>) => STM<boolean, E, R>): (iterable: Iterable<A>) => STM<Array<A>, E, R>;
+    /**
+     * Filters the collection using the specified effectual predicate, removing
+     * all elements that satisfy the predicate.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, R, E>(iterable: Iterable<A>, predicate: (a: A) => STM<boolean, E, R>): STM<Array<A>, E, R>;
 };
 /**
@@ -541,9 +727,33 @@ export declare const filterNot: {
  * @category filtering
  */
 export declare const filterOrDie: {
+    /**
+     * Dies with specified defect if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, defect: LazyArg<unknown>): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
+    /**
+     * Dies with specified defect if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A>(predicate: Predicate<NoInfer<A>>, defect: LazyArg<unknown>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    /**
+     * Dies with specified defect if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E, R, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>, defect: LazyArg<unknown>): STM<B, E, R>;
+    /**
+     * Dies with specified defect if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>, defect: LazyArg<unknown>): STM<A, E, R>;
 };
 /**
@@ -554,9 +764,37 @@ export declare const filterOrDie: {
  * @category filtering
  */
 export declare const filterOrDieMessage: {
+    /**
+     * Dies with a `Cause.RuntimeException` having the specified  message if the
+     * predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>, message: string): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
+    /**
+     * Dies with a `Cause.RuntimeException` having the specified  message if the
+     * predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A>(predicate: Predicate<NoInfer<A>>, message: string): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    /**
+     * Dies with a `Cause.RuntimeException` having the specified  message if the
+     * predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E, R, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>, message: string): STM<B, E, R>;
+    /**
+     * Dies with a `Cause.RuntimeException` having the specified  message if the
+     * predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>, message: string): STM<A, E, R>;
 };
 /**
@@ -566,9 +804,33 @@ export declare const filterOrDieMessage: {
  * @category filtering
  */
 export declare const filterOrElse: {
+    /**
+     * Supplies `orElse` if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B extends A, C, E2, R2>(refinement: Refinement<NoInfer<A>, B>, orElse: (a: NoInfer<A>) => STM<C, E2, R2>): <E, R>(self: STM<A, E, R>) => STM<B | C, E2 | E, R2 | R>;
+    /**
+     * Supplies `orElse` if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B, E2, R2>(predicate: Predicate<NoInfer<A>>, orElse: (a: NoInfer<A>) => STM<B, E2, R2>): <E, R>(self: STM<A, E, R>) => STM<A | B, E2 | E, R2 | R>;
+    /**
+     * Supplies `orElse` if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E, R, B extends A, C, E2, R2>(self: STM<A, E, R>, refinement: Refinement<A, B>, orElse: (a: A) => STM<C, E2, R2>): STM<B | C, E | E2, R | R2>;
+    /**
+     * Supplies `orElse` if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E, R, B, E2, R2>(self: STM<A, E, R>, predicate: Predicate<A>, orElse: (a: A) => STM<B, E2, R2>): STM<A | B, E | E2, R | R2>;
 };
 /**
@@ -578,9 +840,33 @@ export declare const filterOrElse: {
  * @category filtering
  */
 export declare const filterOrFail: {
+    /**
+     * Fails with the specified error if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, B extends A, E2>(refinement: Refinement<NoInfer<A>, B>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: STM<A, E, R>) => STM<B, E2 | E, R>;
+    /**
+     * Fails with the specified error if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E2>(predicate: Predicate<NoInfer<A>>, orFailWith: (a: NoInfer<A>) => E2): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R>;
+    /**
+     * Fails with the specified error if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E, R, B extends A, E2>(self: STM<A, E, R>, refinement: Refinement<A, B>, orFailWith: (a: A) => E2): STM<B, E | E2, R>;
+    /**
+     * Fails with the specified error if the predicate fails.
+     *
+     * @since 2.0.0
+     * @category filtering
+     */
     <A, E, R, E2>(self: STM<A, E, R>, predicate: Predicate<A>, orFailWith: (a: A) => E2): STM<A, E | E2, R>;
 };
 /**
@@ -591,7 +877,21 @@ export declare const filterOrFail: {
  * @category sequencing
  */
 export declare const flatMap: {
+    /**
+     * Feeds the value produced by this effect to the specified function, and then
+     * runs the returned effect as well to produce its results.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <A, A2, E1, R1>(f: (a: A) => STM<A2, E1, R1>): <E, R>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>;
+    /**
+     * Feeds the value produced by this effect to the specified function, and then
+     * runs the returned effect as well to produce its results.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <A, E, R, A2, E1, R1>(self: STM<A, E, R>, f: (a: A) => STM<A2, E1, R1>): STM<A2, E | E1, R | R1>;
 };
 /**
@@ -618,7 +918,21 @@ export declare const flip: <A, E, R>(self: STM<A, E, R>) => STM<E, A, R>;
  * @category mutations
  */
 export declare const flipWith: {
+    /**
+     * Swaps the error/value parameters, applies the function `f` and flips the
+     * parameters back
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <E, A, R, E2, A2, R2>(f: (stm: STM<E, A, R>) => STM<E2, A2, R2>): (self: STM<A, E, R>) => STM<A | A2, E | E2, R | R2>;
+    /**
+     * Swaps the error/value parameters, applies the function `f` and flips the
+     * parameters back
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, E2, A2, R2>(self: STM<A, E, R>, f: (stm: STM<E, A, R>) => STM<E2, A2, R2>): STM<A | A2, E | E2, R | R2>;
 };
 /**
@@ -629,10 +943,24 @@ export declare const flipWith: {
  * @category folding
  */
 export declare const match: {
+    /**
+     * Folds over the `STM` effect, handling both failure and success, but not
+     * retry.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
     <E, A2, A, A3>(options: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
     }): <R>(self: STM<A, E, R>) => STM<A2 | A3, never, R>;
+    /**
+     * Folds over the `STM` effect, handling both failure and success, but not
+     * retry.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
     <A, E, R, A2, A3>(self: STM<A, E, R>, options: {
         readonly onFailure: (error: E) => A2;
         readonly onSuccess: (value: A) => A3;
@@ -645,10 +973,22 @@ export declare const match: {
  * @category folding
  */
 export declare const matchSTM: {
+    /**
+     * Effectfully folds over the `STM` effect, handling both failure and success.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
     <E, A1, E1, R1, A, A2, E2, R2>(options: {
         readonly onFailure: (e: E) => STM<A1, E1, R1>;
         readonly onSuccess: (a: A) => STM<A2, E2, R2>;
     }): <R>(self: STM<A, E, R>) => STM<A1 | A2, E1 | E2, R1 | R2 | R>;
+    /**
+     * Effectfully folds over the `STM` effect, handling both failure and success.
+     *
+     * @since 2.0.0
+     * @category folding
+     */
     <A, E, R, A1, E1, R1, A2, E2, R2>(self: STM<A, E, R>, options: {
         readonly onFailure: (e: E) => STM<A1, E1, R1>;
         readonly onSuccess: (a: A) => STM<A2, E2, R2>;
@@ -662,15 +1002,43 @@ export declare const matchSTM: {
  * @category traversing
  */
 export declare const forEach: {
+    /**
+     * Applies the function `f` to each element of the `Iterable<A>` and returns
+     * a transactional effect that produces a new `Chunk<A2>`.
+     *
+     * @since 2.0.0
+     * @category traversing
+     */
     <A, A2, E, R>(f: (a: A) => STM<A2, E, R>, options?: {
         readonly discard?: false | undefined;
     } | undefined): (elements: Iterable<A>) => STM<Array<A2>, E, R>;
+    /**
+     * Applies the function `f` to each element of the `Iterable<A>` and returns
+     * a transactional effect that produces a new `Chunk<A2>`.
+     *
+     * @since 2.0.0
+     * @category traversing
+     */
     <A, A2, E, R>(f: (a: A) => STM<A2, E, R>, options: {
         readonly discard: true;
     }): (elements: Iterable<A>) => STM<void, E, R>;
+    /**
+     * Applies the function `f` to each element of the `Iterable<A>` and returns
+     * a transactional effect that produces a new `Chunk<A2>`.
+     *
+     * @since 2.0.0
+     * @category traversing
+     */
     <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>, options?: {
         readonly discard?: false | undefined;
     } | undefined): STM<Array<A2>, E, R>;
+    /**
+     * Applies the function `f` to each element of the `Iterable<A>` and returns
+     * a transactional effect that produces a new `Chunk<A2>`.
+     *
+     * @since 2.0.0
+     * @category traversing
+     */
     <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>, options: {
         readonly discard: true;
     }): STM<void, E, R>;
@@ -839,12 +1207,50 @@ export declare const iterate: <Z, E, R>(initial: Z, options: {
  * @category constructors
  */
 export declare const loop: {
+    /**
+     * Loops with the specified transactional function, collecting the results
+     * into a list. The moral equivalent of:
+     *
+     * ```ts
+     * const as = []
+     * let s  = initial
+     *
+     * while (cont(s)) {
+     *   as.push(body(s))
+     *   s  = inc(s)
+     * }
+     *
+     * return as
+     * ```
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <Z, A, E, R>(initial: Z, options: {
         readonly while: (z: Z) => boolean;
         readonly step: (z: Z) => Z;
         readonly body: (z: Z) => STM<A, E, R>;
         readonly discard?: false | undefined;
     }): STM<Array<A>, E, R>;
+    /**
+     * Loops with the specified transactional function, collecting the results
+     * into a list. The moral equivalent of:
+     *
+     * ```ts
+     * const as = []
+     * let s  = initial
+     *
+     * while (cont(s)) {
+     *   as.push(body(s))
+     *   s  = inc(s)
+     * }
+     *
+     * return as
+     * ```
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <Z, A, E, R>(initial: Z, options: {
         readonly while: (z: Z) => boolean;
         readonly step: (z: Z) => Z;
@@ -859,7 +1265,19 @@ export declare const loop: {
  * @category mapping
  */
 export declare const map: {
+    /**
+     * Maps the value produced by the effect.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, B>(f: (a: A) => B): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
+    /**
+     * Maps the value produced by the effect.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, E, R, B>(self: STM<A, E, R>, f: (a: A) => B): STM<B, E, R>;
 };
 /**
@@ -871,7 +1289,23 @@ export declare const map: {
  * @category mapping
  */
 export declare const mapAttempt: {
+    /**
+     * Maps the value produced by the effect with the specified function that may
+     * throw exceptions but is otherwise pure, translating any thrown exceptions
+     * into typed failed effects.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, B>(f: (a: A) => B): <E, R>(self: STM<A, E, R>) => STM<B, unknown, R>;
+    /**
+     * Maps the value produced by the effect with the specified function that may
+     * throw exceptions but is otherwise pure, translating any thrown exceptions
+     * into typed failed effects.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, E, R, B>(self: STM<A, E, R>, f: (a: A) => B): STM<B, unknown, R>;
 };
 /**
@@ -882,10 +1316,24 @@ export declare const mapAttempt: {
  * @category mapping
  */
 export declare const mapBoth: {
+    /**
+     * Returns an `STM` effect whose failure and success channels have been mapped
+     * by the specified pair of functions, `f` and `g`.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <E, E2, A, A2>(options: {
         readonly onFailure: (error: E) => E2;
         readonly onSuccess: (value: A) => A2;
     }): <R>(self: STM<A, E, R>) => STM<A2, E2, R>;
+    /**
+     * Returns an `STM` effect whose failure and success channels have been mapped
+     * by the specified pair of functions, `f` and `g`.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, E, R, E2, A2>(self: STM<A, E, R>, options: {
         readonly onFailure: (error: E) => E2;
         readonly onSuccess: (value: A) => A2;
@@ -898,7 +1346,19 @@ export declare const mapBoth: {
  * @category mapping
  */
 export declare const mapError: {
+    /**
+     * Maps from one error type to another.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <E, E2>(f: (error: E) => E2): <A, R>(self: STM<A, E, R>) => STM<A, E2, R>;
+    /**
+     * Maps from one error type to another.
+     *
+     * @since 2.0.0
+     * @category mapping
+     */
     <A, E, R, E2>(self: STM<A, E, R>, f: (error: E) => E2): STM<A, E2, R>;
 };
 /**
@@ -916,7 +1376,19 @@ export declare const merge: <A, E, R>(self: STM<A, E, R>) => STM<E | A, never, R
  * @category constructors
  */
 export declare const mergeAll: {
+    /**
+     * Merges an `Iterable<STM>` to a single `STM`, working sequentially.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A2, A>(zero: A2, f: (a2: A2, a: A) => A2): <E, R>(iterable: Iterable<STM<A, E, R>>) => STM<A2, E, R>;
+    /**
+     * Merges an `Iterable<STM>` to a single `STM`, working sequentially.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, E, R, A2>(iterable: Iterable<STM<A, E, R>>, zero: A2, f: (a2: A2, a: A) => A2): STM<A2, E, R>;
 };
 /**
@@ -956,7 +1428,21 @@ export declare const orDie: <A, E, R>(self: STM<A, E, R>) => STM<A, never, R>;
  * @category error handling
  */
 export declare const orDieWith: {
+    /**
+     * Keeps none of the errors, and terminates the fiber running the `STM` effect
+     * with them, using the specified function to convert the `E` into a defect.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <E>(f: (error: E) => unknown): <A, R>(self: STM<A, E, R>) => STM<A, never, R>;
+    /**
+     * Keeps none of the errors, and terminates the fiber running the `STM` effect
+     * with them, using the specified function to convert the `E` into a defect.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R>(self: STM<A, E, R>, f: (error: E) => unknown): STM<A, never, R>;
 };
 /**
@@ -967,7 +1453,21 @@ export declare const orDieWith: {
  * @category error handling
  */
 export declare const orElse: {
+    /**
+     * Tries this effect first, and if it fails or retries, tries the other
+     * effect.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A2, E2, R2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, E2, R2 | R>;
+    /**
+     * Tries this effect first, and if it fails or retries, tries the other
+     * effect.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R, A2, E2, R2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<A | A2, E2, R | R2>;
 };
 /**
@@ -979,7 +1479,23 @@ export declare const orElse: {
  * @category error handling
  */
 export declare const orElseEither: {
+    /**
+     * Returns a transactional effect that will produce the value of this effect
+     * in left side, unless it fails or retries, in which case, it will produce
+     * the value of the specified effect in right side.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A2, E2, R2>(that: LazyArg<STM<A2, E2, R2>>): <A, E, R>(self: STM<A, E, R>) => STM<Either.Either<A2, A>, E2, R2 | R>;
+    /**
+     * Returns a transactional effect that will produce the value of this effect
+     * in left side, unless it fails or retries, in which case, it will produce
+     * the value of the specified effect in right side.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R, A2, E2, R2>(self: STM<A, E, R>, that: LazyArg<STM<A2, E2, R2>>): STM<Either.Either<A2, A>, E2, R | R2>;
 };
 /**
@@ -990,7 +1506,21 @@ export declare const orElseEither: {
  * @category error handling
  */
 export declare const orElseFail: {
+    /**
+     * Tries this effect first, and if it fails or retries, fails with the
+     * specified error.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <E2>(error: LazyArg<E2>): <A, E, R>(self: STM<A, E, R>) => STM<A, E2, R>;
+    /**
+     * Tries this effect first, and if it fails or retries, fails with the
+     * specified error.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R, E2>(self: STM<A, E, R>, error: LazyArg<E2>): STM<A, E2, R>;
 };
 /**
@@ -1002,7 +1532,23 @@ export declare const orElseFail: {
  * @category error handling
  */
 export declare const orElseOptional: {
+    /**
+     * Returns an effect that will produce the value of this effect, unless it
+     * fails with the `None` value, in which case it will produce the value of the
+     * specified effect.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A2, E2, R2>(that: LazyArg<STM<A2, Option.Option<E2>, R2>>): <A, E, R>(self: STM<A, Option.Option<E>, R>) => STM<A2 | A, Option.Option<E2 | E>, R2 | R>;
+    /**
+     * Returns an effect that will produce the value of this effect, unless it
+     * fails with the `None` value, in which case it will produce the value of the
+     * specified effect.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R, A2, E2, R2>(self: STM<A, Option.Option<E>, R>, that: LazyArg<STM<A2, Option.Option<E2>, R2>>): STM<A | A2, Option.Option<E | E2>, R | R2>;
 };
 /**
@@ -1013,7 +1559,21 @@ export declare const orElseOptional: {
  * @category error handling
  */
 export declare const orElseSucceed: {
+    /**
+     * Tries this effect first, and if it fails or retries, succeeds with the
+     * specified value.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A2>(value: LazyArg<A2>): <A, E, R>(self: STM<A, E, R>) => STM<A2 | A, never, R>;
+    /**
+     * Tries this effect first, and if it fails or retries, succeeds with the
+     * specified value.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R, A2>(self: STM<A, E, R>, value: LazyArg<A2>): STM<A | A2, never, R>;
 };
 /**
@@ -1024,7 +1584,21 @@ export declare const orElseSucceed: {
  * @category error handling
  */
 export declare const orTry: {
+    /**
+     * Tries this effect first, and if it enters retry, then it tries the other
+     * effect. This is an equivalent of Haskell's orElse.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A1, E1, R1>(that: LazyArg<STM<A1, E1, R1>>): <A, E, R>(self: STM<A, E, R>) => STM<A1 | A, E1 | E, R1 | R>;
+    /**
+     * Tries this effect first, and if it enters retry, then it tries the other
+     * effect. This is an equivalent of Haskell's orElse.
+     *
+     * @since 2.0.0
+     * @category error handling
+     */
     <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: LazyArg<STM<A1, E1, R1>>): STM<A | A1, E | E1, R | R1>;
 };
 /**
@@ -1035,7 +1609,21 @@ export declare const orTry: {
  * @category traversing
  */
 export declare const partition: {
+    /**
+     * Feeds elements of type `A` to a function `f` that returns an effect.
+     * Collects all successes and failures in a tupled fashion.
+     *
+     * @since 2.0.0
+     * @category traversing
+     */
     <A, A2, E, R>(f: (a: A) => STM<A2, E, R>): (elements: Iterable<A>) => STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>;
+    /**
+     * Feeds elements of type `A` to a function `f` that returns an effect.
+     * Collects all successes and failures in a tupled fashion.
+     *
+     * @since 2.0.0
+     * @category traversing
+     */
     <A, A2, E, R>(elements: Iterable<A>, f: (a: A) => STM<A2, E, R>): STM<[excluded: Array<E>, satisfying: Array<A2>], never, R>;
 };
 /**
@@ -1046,7 +1634,21 @@ export declare const partition: {
  * @category context
  */
 export declare const provideContext: {
+    /**
+     * Provides the transaction its required environment, which eliminates its
+     * dependency on `R`.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <R>(env: Context.Context<R>): <A, E>(self: STM<A, E, R>) => STM<A, E>;
+    /**
+     * Provides the transaction its required environment, which eliminates its
+     * dependency on `R`.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <A, E, R>(self: STM<A, E, R>, env: Context.Context<R>): STM<A, E>;
 };
 /**
@@ -1057,7 +1659,21 @@ export declare const provideContext: {
  * @category context
  */
 export declare const provideSomeContext: {
+    /**
+     * Splits the context into two parts, providing one part using the
+     * specified layer and leaving the remainder `R0`.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <R>(context: Context.Context<R>): <R1, E, A>(self: STM<A, E, R1>) => STM<A, E, Exclude<R1, R>>;
+    /**
+     * Splits the context into two parts, providing one part using the
+     * specified layer and leaving the remainder `R0`.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <R, R1, E, A>(self: STM<A, E, R1>, context: Context.Context<R>): STM<A, E, Exclude<R1, R>>;
 };
 /**
@@ -1068,7 +1684,21 @@ export declare const provideSomeContext: {
  * @category context
  */
 export declare const provideService: {
+    /**
+     * Provides the effect with the single service it requires. If the transactional
+     * effect requires more than one service use `provideEnvironment` instead.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <T extends Context.Tag<any, any>>(tag: T, resource: Context.Tag.Service<T>): <A, E, R>(self: STM<A, E, R>) => STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
+    /**
+     * Provides the effect with the single service it requires. If the transactional
+     * effect requires more than one service use `provideEnvironment` instead.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <A, E, R, T extends Context.Tag<any, any>>(self: STM<A, E, R>, tag: T, resource: Context.Tag.Service<T>): STM<A, E, Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
@@ -1079,7 +1709,21 @@ export declare const provideService: {
  * @category context
  */
 export declare const provideServiceSTM: {
+    /**
+     * Provides the effect with the single service it requires. If the transactional
+     * effect requires more than one service use `provideEnvironment` instead.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <T extends Context.Tag<any, any>, E1, R1>(tag: T, stm: STM<Context.Tag.Service<T>, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
+    /**
+     * Provides the effect with the single service it requires. If the transactional
+     * effect requires more than one service use `provideEnvironment` instead.
+     *
+     * @since 2.0.0
+     * @category context
+     */
     <A, E, R, T extends Context.Tag<any, any>, E1, R1>(self: STM<A, E, R>, tag: T, stm: STM<Context.Tag.Service<T>, E1, R1>): STM<A, E | E1, R1 | Exclude<R, Context.Tag.Identifier<T>>>;
 };
 /**
@@ -1090,7 +1734,21 @@ export declare const provideServiceSTM: {
  * @category constructors
  */
 export declare const reduce: {
+    /**
+     * Folds an `Iterable<A>` using an effectual function f, working sequentially
+     * from left to right.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <S, A, E, R>(zero: S, f: (s: S, a: A) => STM<S, E, R>): (iterable: Iterable<A>) => STM<S, E, R>;
+    /**
+     * Folds an `Iterable<A>` using an effectual function f, working sequentially
+     * from left to right.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <S, A, E, R>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<S, E, R>): STM<S, E, R>;
 };
 /**
@@ -1100,7 +1758,19 @@ export declare const reduce: {
  * @category constructors
  */
 export declare const reduceAll: {
+    /**
+     * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, E2, R2>(initial: STM<A, E2, R2>, f: (x: A, y: A) => A): <E, R>(iterable: Iterable<STM<A, E, R>>) => STM<A, E2 | E, R2 | R>;
+    /**
+     * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, E, R, E2, R2>(iterable: Iterable<STM<A, E, R>>, initial: STM<A, E2, R2>, f: (x: A, y: A) => A): STM<A, E | E2, R | R2>;
 };
 /**
@@ -1111,7 +1781,21 @@ export declare const reduceAll: {
  * @category constructors
  */
 export declare const reduceRight: {
+    /**
+     * Folds an `Iterable<A>` using an effectual function f, working sequentially
+     * from right to left.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <S, A, R, E>(zero: S, f: (s: S, a: A) => STM<S, E, R>): (iterable: Iterable<A>) => STM<S, E, R>;
+    /**
+     * Folds an `Iterable<A>` using an effectual function f, working sequentially
+     * from right to left.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <S, A, R, E>(iterable: Iterable<A>, zero: S, f: (s: S, a: A) => STM<S, E, R>): STM<S, E, R>;
 };
 /**
@@ -1121,7 +1805,19 @@ export declare const reduceRight: {
  * @category mutations
  */
 export declare const refineOrDie: {
+    /**
+     * Keeps some of the errors, and terminates the fiber with the rest.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <E, E2>(pf: (error: E) => Option.Option<E2>): <A, R>(self: STM<A, E, R>) => STM<A, E2, R>;
+    /**
+     * Keeps some of the errors, and terminates the fiber with the rest.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, E2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<E2>): STM<A, E2, R>;
 };
 /**
@@ -1132,7 +1828,21 @@ export declare const refineOrDie: {
  * @category mutations
  */
 export declare const refineOrDieWith: {
+    /**
+     * Keeps some of the errors, and terminates the fiber with the rest, using the
+     * specified function to convert the `E` into a `Throwable`.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <E, E2>(pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): <A, R>(self: STM<A, E, R>) => STM<A, E2, R>;
+    /**
+     * Keeps some of the errors, and terminates the fiber with the rest, using the
+     * specified function to convert the `E` into a `Throwable`.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, E2>(self: STM<A, E, R>, pf: (error: E) => Option.Option<E2>, f: (error: E) => unknown): STM<A, E2, R>;
 };
 /**
@@ -1143,7 +1853,21 @@ export declare const refineOrDieWith: {
  * @category mutations
  */
 export declare const reject: {
+    /**
+     * Fail with the returned value if the `PartialFunction` matches, otherwise
+     * continue with our held value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E2>(pf: (a: A) => Option.Option<E2>): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R>;
+    /**
+     * Fail with the returned value if the `PartialFunction` matches, otherwise
+     * continue with our held value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, E2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<E2>): STM<A, E | E2, R>;
 };
 /**
@@ -1155,7 +1879,23 @@ export declare const reject: {
  * @category mutations
  */
 export declare const rejectSTM: {
+    /**
+     * Continue with the returned computation if the specified partial function
+     * matches, translating the successful match into a failure, otherwise continue
+     * with our held value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E2, R2>(pf: (a: A) => Option.Option<STM<E2, E2, R2>>): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R2 | R>;
+    /**
+     * Continue with the returned computation if the specified partial function
+     * matches, translating the successful match into a failure, otherwise continue
+     * with our held value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, E2, R2>(self: STM<A, E, R>, pf: (a: A) => Option.Option<STM<E2, E2, R2>>): STM<A, E | E2, R | R2>;
 };
 /**
@@ -1174,7 +1914,37 @@ export declare const rejectSTM: {
  * @category mutations
  */
 export declare const repeatUntil: {
+    /**
+     * Repeats this `STM` effect until its result satisfies the specified
+     * predicate.
+     *
+     * **WARNING**: `repeatUntil` uses a busy loop to repeat the effect and will
+     * consume a thread until it completes (it cannot yield). This is because STM
+     * describes a single atomic transaction which must either complete, retry or
+     * fail a transaction before yielding back to the Effect runtime.
+     *   - Use `retryUntil` instead if you don't need to maintain transaction
+     *     state for repeats.
+     *   - Ensure repeating the STM effect will eventually satisfy the predicate.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A>(predicate: Predicate<A>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    /**
+     * Repeats this `STM` effect until its result satisfies the specified
+     * predicate.
+     *
+     * **WARNING**: `repeatUntil` uses a busy loop to repeat the effect and will
+     * consume a thread until it completes (it cannot yield). This is because STM
+     * describes a single atomic transaction which must either complete, retry or
+     * fail a transaction before yielding back to the Effect runtime.
+     *   - Use `retryUntil` instead if you don't need to maintain transaction
+     *     state for repeats.
+     *   - Ensure repeating the STM effect will eventually satisfy the predicate.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
@@ -1194,7 +1964,39 @@ export declare const repeatUntil: {
  * @category mutations
  */
 export declare const repeatWhile: {
+    /**
+     * Repeats this `STM` effect while its result satisfies the specified
+     * predicate.
+     *
+     * **WARNING**: `repeatWhile` uses a busy loop to repeat the effect and will
+     * consume a thread until it completes (it cannot yield). This is because STM
+     * describes a single atomic transaction which must either complete, retry or
+     * fail a transaction before yielding back to the Effect runtime.
+     *   - Use `retryWhile` instead if you don't need to maintain transaction
+     *     state for repeats.
+     *   - Ensure repeating the STM effect will eventually not satisfy the
+     *     predicate.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A>(predicate: Predicate<A>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    /**
+     * Repeats this `STM` effect while its result satisfies the specified
+     * predicate.
+     *
+     * **WARNING**: `repeatWhile` uses a busy loop to repeat the effect and will
+     * consume a thread until it completes (it cannot yield). This is because STM
+     * describes a single atomic transaction which must either complete, retry or
+     * fail a transaction before yielding back to the Effect runtime.
+     *   - Use `retryWhile` instead if you don't need to maintain transaction
+     *     state for repeats.
+     *   - Ensure repeating the STM effect will eventually not satisfy the
+     *     predicate.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
@@ -1205,7 +2007,21 @@ export declare const repeatWhile: {
  * @category constructors
  */
 export declare const replicate: {
+    /**
+     * Replicates the given effect n times. If 0 or negative numbers are given, an
+     * empty `Chunk` will be returned.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     (n: number): <A, E, R>(self: STM<A, E, R>) => Array<STM<A, E, R>>;
+    /**
+     * Replicates the given effect n times. If 0 or negative numbers are given, an
+     * empty `Chunk` will be returned.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, E, R>(self: STM<A, E, R>, n: number): Array<STM<A, E, R>>;
 };
 /**
@@ -1216,7 +2032,21 @@ export declare const replicate: {
  * @category constructors
  */
 export declare const replicateSTM: {
+    /**
+     * Performs this transaction the specified number of times and collects the
+     * results.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     (n: number): <A, E, R>(self: STM<A, E, R>) => STM<Array<A>, E, R>;
+    /**
+     * Performs this transaction the specified number of times and collects the
+     * results.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, E, R>(self: STM<A, E, R>, n: number): STM<Array<A>, E, R>;
 };
 /**
@@ -1227,7 +2057,21 @@ export declare const replicateSTM: {
  * @category constructors
  */
 export declare const replicateSTMDiscard: {
+    /**
+     * Performs this transaction the specified number of times, discarding the
+     * results.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     (n: number): <A, E, R>(self: STM<A, E, R>) => STM<void, E, R>;
+    /**
+     * Performs this transaction the specified number of times, discarding the
+     * results.
+     *
+     * @since 2.0.0
+     * @category constructors
+     */
     <A, E, R>(self: STM<A, E, R>, n: number): STM<void, E, R>;
 };
 /**
@@ -1246,9 +2090,37 @@ export declare const retry: STM<never>;
  * @category mutations
  */
 export declare const retryUntil: {
+    /**
+     * Filters the value produced by this effect, retrying the transaction until
+     * the predicate returns `true` for the value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E, R>(self: STM<A, E, R>) => STM<B, E, R>;
+    /**
+     * Filters the value produced by this effect, retrying the transaction until
+     * the predicate returns `true` for the value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A>(predicate: Predicate<A>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    /**
+     * Filters the value produced by this effect, retrying the transaction until
+     * the predicate returns `true` for the value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, B extends A>(self: STM<A, E, R>, refinement: Refinement<A, B>): STM<B, E, R>;
+    /**
+     * Filters the value produced by this effect, retrying the transaction until
+     * the predicate returns `true` for the value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
@@ -1259,7 +2131,21 @@ export declare const retryUntil: {
  * @category mutations
  */
 export declare const retryWhile: {
+    /**
+     * Filters the value produced by this effect, retrying the transaction while
+     * the predicate returns `true` for the value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A>(predicate: Predicate<A>): <E, R>(self: STM<A, E, R>) => STM<A, E, R>;
+    /**
+     * Filters the value produced by this effect, retrying the transaction while
+     * the predicate returns `true` for the value.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R>(self: STM<A, E, R>, predicate: Predicate<A>): STM<A, E, R>;
 };
 /**
@@ -1299,7 +2185,23 @@ export declare const succeedSome: <A>(value: A) => STM<Option.Option<A>>;
  * @category mutations
  */
 export declare const summarized: {
+    /**
+     * Summarizes a `STM` effect by computing a provided value before and after
+     * execution, and then combining the values to produce a summary, together
+     * with the result of execution.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A2, E2, R2, A3>(summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): <A, E, R>(self: STM<A, E, R>) => STM<[A3, A], E2 | E, R2 | R>;
+    /**
+     * Summarizes a `STM` effect by computing a provided value before and after
+     * execution, and then combining the values to produce a summary, together
+     * with the result of execution.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, A2, E2, R2, A3>(self: STM<A, E, R>, summary: STM<A2, E2, R2>, f: (before: A2, after: A2) => A3): STM<[A3, A], E | E2, R | R2>;
 };
 /**
@@ -1324,7 +2226,19 @@ export declare const sync: <A>(evaluate: () => A) => STM<A>;
  * @category sequencing
  */
 export declare const tap: {
+    /**
+     * "Peeks" at the success of transactional effect.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <A, X, E2, R2>(f: (a: A) => STM<X, E2, R2>): <E, R>(self: STM<A, E, R>) => STM<A, E2 | E, R2 | R>;
+    /**
+     * "Peeks" at the success of transactional effect.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <A, E, R, X, E2, R2>(self: STM<A, E, R>, f: (a: A) => STM<X, E2, R2>): STM<A, E | E2, R | R2>;
 };
 /**
@@ -1334,10 +2248,22 @@ export declare const tap: {
  * @category sequencing
  */
 export declare const tapBoth: {
+    /**
+     * "Peeks" at both sides of an transactional effect.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <XE extends E, A2, E2, R2, XA extends A, A3, E3, R3, A, E>(options: {
         readonly onFailure: (error: XE) => STM<A2, E2, R2>;
         readonly onSuccess: (value: XA) => STM<A3, E3, R3>;
     }): <R>(self: STM<A, E, R>) => STM<A, E | E2 | E3, R2 | R3 | R>;
+    /**
+     * "Peeks" at both sides of an transactional effect.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <A, E, R, XE extends E, A2, E2, R2, XA extends A, A3, E3, R3>(self: STM<A, E, R>, options: {
         readonly onFailure: (error: XE) => STM<A2, E2, R2>;
         readonly onSuccess: (value: XA) => STM<A3, E3, R3>;
@@ -1350,7 +2276,19 @@ export declare const tapBoth: {
  * @category sequencing
  */
 export declare const tapError: {
+    /**
+     * "Peeks" at the error of the transactional effect.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <E, X, E2, R2>(f: (error: NoInfer<E>) => STM<X, E2, R2>): <A, R>(self: STM<A, E, R>) => STM<A, E | E2, R2 | R>;
+    /**
+     * "Peeks" at the error of the transactional effect.
+     *
+     * @since 2.0.0
+     * @category sequencing
+     */
     <A, E, R, X, E2, R2>(self: STM<A, E, R>, f: (error: E) => STM<X, E2, R2>): STM<A, E | E2, R | R2>;
 };
 declare const try_: {
@@ -1376,7 +2314,19 @@ try_ as try };
  * @category mutations
  */
 export declare const unless: {
+    /**
+     * The moral equivalent of `if (!p) exp`
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     (predicate: LazyArg<boolean>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E, R>;
+    /**
+     * The moral equivalent of `if (!p) exp`
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R>(self: STM<A, E, R>, predicate: LazyArg<boolean>): STM<Option.Option<A>, E, R>;
 };
 /**
@@ -1386,7 +2336,19 @@ export declare const unless: {
  * @category mutations
  */
 export declare const unlessSTM: {
+    /**
+     * The moral equivalent of `if (!p) exp` when `p` has side-effects
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <E2, R2>(predicate: STM<boolean, E2, R2>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E2 | E, R2 | R>;
+    /**
+     * The moral equivalent of `if (!p) exp` when `p` has side-effects
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, E2, R2>(self: STM<A, E, R>, predicate: STM<boolean, E2, R2>): STM<Option.Option<A>, E | E2, R | R2>;
 };
 /**
@@ -1416,7 +2378,27 @@ void_ as void };
  * @category mutations
  */
 export declare const validateAll: {
+    /**
+     * Feeds elements of type `A` to `f` and accumulates all errors in error
+     * channel or successes in success channel.
+     *
+     * This combinator is lossy meaning that if there are errors all successes
+     * will be lost. To retain all information please use `STM.partition`.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, B, E, R>(f: (a: A) => STM<B, E, R>): (elements: Iterable<A>) => STM<Array<B>, [E, ...Array<E>], R>;
+    /**
+     * Feeds elements of type `A` to `f` and accumulates all errors in error
+     * channel or successes in success channel.
+     *
+     * This combinator is lossy meaning that if there are errors all successes
+     * will be lost. To retain all information please use `STM.partition`.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, B, E, R>(elements: Iterable<A>, f: (a: A) => STM<B, E, R>): STM<Array<B>, [E, ...Array<E>], R>;
 };
 /**
@@ -1427,7 +2409,21 @@ export declare const validateAll: {
  * @category mutations
  */
 export declare const validateFirst: {
+    /**
+     * Feeds elements of type `A` to `f` until it succeeds. Returns first success
+     * or the accumulation of all errors.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, B, E, R>(f: (a: A) => STM<B, E, R>): (elements: Iterable<A>) => STM<B, Array<E>, R>;
+    /**
+     * Feeds elements of type `A` to `f` until it succeeds. Returns first success
+     * or the accumulation of all errors.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, B, E, R>(elements: Iterable<A>, f: (a: A) => STM<B, E, R>): STM<B, Array<E>, R>;
 };
 /**
@@ -1437,7 +2433,19 @@ export declare const validateFirst: {
  * @category mutations
  */
 export declare const when: {
+    /**
+     * The moral equivalent of `if (p) exp`.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     (predicate: LazyArg<boolean>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E, R>;
+    /**
+     * The moral equivalent of `if (p) exp`.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R>(self: STM<A, E, R>, predicate: LazyArg<boolean>): STM<Option.Option<A>, E, R>;
 };
 /**
@@ -1447,7 +2455,19 @@ export declare const when: {
  * @category mutations
  */
 export declare const whenSTM: {
+    /**
+     * The moral equivalent of `if (p) exp` when `p` has side-effects.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <E2, R2>(predicate: STM<boolean, E2, R2>): <A, E, R>(self: STM<A, E, R>) => STM<Option.Option<A>, E2 | E, R2 | R>;
+    /**
+     * The moral equivalent of `if (p) exp` when `p` has side-effects.
+     *
+     * @since 2.0.0
+     * @category mutations
+     */
     <A, E, R, E2, R2>(self: STM<A, E, R>, predicate: STM<boolean, E2, R2>): STM<Option.Option<A>, E | E2, R | R2>;
 };
 /**
@@ -1457,7 +2477,19 @@ export declare const whenSTM: {
  * @category zipping
  */
 export declare const zip: {
+    /**
+     * Sequentially zips this value with the specified one.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A1, E1, R1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<[A, A1], E1 | E, R1 | R>;
+    /**
+     * Sequentially zips this value with the specified one.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<[A, A1], E | E1, R | R1>;
 };
 /**
@@ -1468,7 +2500,21 @@ export declare const zip: {
  * @category zipping
  */
 export declare const zipLeft: {
+    /**
+     * Sequentially zips this value with the specified one, discarding the second
+     * element of the tuple.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A1, E1, R1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A, E1 | E, R1 | R>;
+    /**
+     * Sequentially zips this value with the specified one, discarding the second
+     * element of the tuple.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<A, E | E1, R | R1>;
 };
 /**
@@ -1479,7 +2525,21 @@ export declare const zipLeft: {
  * @category zipping
  */
 export declare const zipRight: {
+    /**
+     * Sequentially zips this value with the specified one, discarding the first
+     * element of the tuple.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A1, E1, R1>(that: STM<A1, E1, R1>): <A, E, R>(self: STM<A, E, R>) => STM<A1, E1 | E, R1 | R>;
+    /**
+     * Sequentially zips this value with the specified one, discarding the first
+     * element of the tuple.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A, E, R, A1, E1, R1>(self: STM<A, E, R>, that: STM<A1, E1, R1>): STM<A1, E | E1, R | R1>;
 };
 /**
@@ -1490,7 +2550,21 @@ export declare const zipRight: {
  * @category zipping
  */
 export declare const zipWith: {
+    /**
+     * Sequentially zips this value with the specified one, combining the values
+     * using the specified combiner function.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A1, E1, R1, A, A2>(that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): <E, R>(self: STM<A, E, R>) => STM<A2, E1 | E, R1 | R>;
+    /**
+     * Sequentially zips this value with the specified one, combining the values
+     * using the specified combiner function.
+     *
+     * @since 2.0.0
+     * @category zipping
+     */
     <A, E, R, A1, E1, R1, A2>(self: STM<A, E, R>, that: STM<A1, E1, R1>, f: (a: A, b: A1) => A2): STM<A2, E | E1, R | R1>;
 };
 /**
@@ -1523,9 +2597,17 @@ export declare const Do: STM<{}>;
  * @since 2.0.0
  */
 export declare const bind: {
+    /**
+     * @category do notation
+     * @since 2.0.0
+     */
     <N extends string, K, A, E2, R2>(tag: Exclude<N, keyof K>, f: (_: K) => STM<A, E2, R2>): <E, R>(self: STM<K, E, R>) => STM<MergeRecord<K, {
         [k in N]: A;
     }>, E2 | E, R2 | R>;
+    /**
+     * @category do notation
+     * @since 2.0.0
+     */
     <K, E, R, N extends string, A, E2, R2>(self: STM<K, E, R>, tag: Exclude<N, keyof K>, f: (_: K) => STM<A, E2, R2>): STM<MergeRecord<K, {
         [k in N]: A;
     }>, E | E2, R | R2>;
@@ -1549,7 +2631,15 @@ let_ as let };
  * @since 2.0.0
  */
 export declare const bindTo: {
+    /**
+     * @category do notation
+     * @since 2.0.0
+     */
     <N extends string>(tag: N): <A, E, R>(self: STM<A, E, R>) => STM<Record<N, A>, E, R>;
+    /**
+     * @category do notation
+     * @since 2.0.0
+     */
     <A, E, R, N extends string>(self: STM<A, E, R>, tag: N): STM<Record<N, A>, E, R>;
 };
 //# sourceMappingURL=STM.d.ts.map