effect 4.0.0-beta.67 → 4.0.0-beta.69

package/dist/BigInt.d.ts

@@ -16,7 +16,7 @@ import * as Reducer from "./Reducer.ts";
  * **Example** (Constructing bigints)
  *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  *
  * const bigInt = BigInt.BigInt(123)
  * console.log(bigInt) // 123n
@@ -35,11 +35,11 @@ export declare const BigInt: BigIntConstructor;
  * **Example** (Checking for bigints)
  *
  * ```ts
- * import { isBigInt } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isBigInt(1n), true)
- * assert.deepStrictEqual(isBigInt(1), false)
+ * assert.deepStrictEqual(BigInt.isBigInt(1n), true)
+ * assert.deepStrictEqual(BigInt.isBigInt(1), false)
  * ```
  *
  * @category guards
@@ -52,10 +52,10 @@ export declare const isBigInt: (u: unknown) => u is bigint;
  * **Example** (Adding bigints)
  *
  * ```ts
- * import { sum } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sum(2n, 3n), 5n)
+ * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
  * ```
  *
  * @category math
@@ -68,10 +68,10 @@ export declare const sum: {
      * **Example** (Adding bigints)
      *
      * ```ts
-     * import { sum } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(sum(2n, 3n), 5n)
+     * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
      * ```
      *
      * @category math
@@ -84,10 +84,10 @@ export declare const sum: {
      * **Example** (Adding bigints)
      *
      * ```ts
-     * import { sum } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(sum(2n, 3n), 5n)
+     * assert.deepStrictEqual(BigInt.sum(2n, 3n), 5n)
      * ```
      *
      * @category math
@@ -101,10 +101,10 @@ export declare const sum: {
  * **Example** (Multiplying bigints)
  *
  * ```ts
- * import { multiply } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+ * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
  * ```
  *
  * @category math
@@ -117,10 +117,10 @@ export declare const multiply: {
      * **Example** (Multiplying bigints)
      *
      * ```ts
-     * import { multiply } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+     * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
      * ```
      *
      * @category math
@@ -133,10 +133,10 @@ export declare const multiply: {
      * **Example** (Multiplying bigints)
      *
      * ```ts
-     * import { multiply } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(multiply(2n, 3n), 6n)
+     * assert.deepStrictEqual(BigInt.multiply(2n, 3n), 6n)
      * ```
      *
      * @category math
@@ -150,10 +150,10 @@ export declare const multiply: {
  * **Example** (Subtracting bigints)
  *
  * ```ts
- * import { subtract } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+ * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
  * ```
  *
  * @category math
@@ -166,10 +166,10 @@ export declare const subtract: {
      * **Example** (Subtracting bigints)
      *
      * ```ts
-     * import { subtract } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+     * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
      * ```
      *
      * @category math
@@ -182,10 +182,10 @@ export declare const subtract: {
      * **Example** (Subtracting bigints)
      *
      * ```ts
-     * import { subtract } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(subtract(2n, 3n), -1n)
+     * assert.deepStrictEqual(BigInt.subtract(2n, 3n), -1n)
      * ```
      *
      * @category math
@@ -202,13 +202,11 @@ export declare const subtract: {
  * **Example** (Dividing bigints safely)
  *
  * ```ts
- * import { divide } from "effect/BigInt"
+ * import { BigInt, Option } from "effect"
  * import * as assert from "node:assert"
  *
- * import { Option } from "effect"
- *
- * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
- * assert.deepStrictEqual(divide(6n, 0n), Option.none())
+ * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+ * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
  * ```
  *
  * @category math
@@ -224,13 +222,11 @@ export declare const divide: {
      * **Example** (Dividing bigints safely)
      *
      * ```ts
-     * import { divide } from "effect/BigInt"
+     * import { BigInt, Option } from "effect"
      * import * as assert from "node:assert"
      *
-     * import { Option } from "effect"
-     *
-     * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
-     * assert.deepStrictEqual(divide(6n, 0n), Option.none())
+     * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+     * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
      * ```
      *
      * @category math
@@ -246,13 +242,11 @@ export declare const divide: {
      * **Example** (Dividing bigints safely)
      *
      * ```ts
-     * import { divide } from "effect/BigInt"
+     * import { BigInt, Option } from "effect"
      * import * as assert from "node:assert"
      *
-     * import { Option } from "effect"
-     *
-     * assert.deepStrictEqual(divide(6n, 3n), Option.some(2n))
-     * assert.deepStrictEqual(divide(6n, 0n), Option.none())
+     * assert.deepStrictEqual(BigInt.divide(6n, 3n), Option.some(2n))
+     * assert.deepStrictEqual(BigInt.divide(6n, 0n), Option.none())
      * ```
      *
      * @category math
@@ -269,15 +263,15 @@ export declare const divide: {
  * **Example** (Dividing bigints unsafely)
  *
  * ```ts
- * import { divideUnsafe } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(divideUnsafe(6n, 3n), 2n)
- * assert.deepStrictEqual(divideUnsafe(6n, 4n), 1n)
+ * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
+ * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const divideUnsafe: {
     /**
@@ -289,15 +283,15 @@ export declare const divideUnsafe: {
      * **Example** (Dividing bigints unsafely)
      *
      * ```ts
-     * import { divideUnsafe } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(divideUnsafe(6n, 3n), 2n)
-     * assert.deepStrictEqual(divideUnsafe(6n, 4n), 1n)
+     * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
+     * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
      * ```
      *
      * @category math
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: bigint): (self: bigint) => bigint;
     /**
@@ -309,15 +303,15 @@ export declare const divideUnsafe: {
      * **Example** (Dividing bigints unsafely)
      *
      * ```ts
-     * import { divideUnsafe } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(divideUnsafe(6n, 3n), 2n)
-     * assert.deepStrictEqual(divideUnsafe(6n, 4n), 1n)
+     * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 3n), 2n)
+     * assert.deepStrictEqual(BigInt.divideUnsafe(6n, 4n), 1n)
      * ```
      *
      * @category math
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: bigint, that: bigint): bigint;
 };
@@ -327,10 +321,10 @@ export declare const divideUnsafe: {
  * **Example** (Incrementing a bigint)
  *
  * ```ts
- * import { increment } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(increment(2n), 3n)
+ * assert.deepStrictEqual(BigInt.increment(2n), 3n)
  * ```
  *
  * @category math
@@ -343,10 +337,10 @@ export declare const increment: (n: bigint) => bigint;
  * **Example** (Decrementing a bigint)
  *
  * ```ts
- * import { decrement } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(decrement(3n), 2n)
+ * assert.deepStrictEqual(BigInt.decrement(3n), 2n)
  * ```
  *
  * @category math
@@ -359,7 +353,7 @@ export declare const decrement: (n: bigint) => bigint;
  * **Example** (Comparing bigints with Order)
  *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  *
  * const a = 123n
  * const b = 456n
@@ -387,7 +381,7 @@ export declare const Order: order.Order<bigint>;
  * ```
  *
  * @category instances
- * @since 4.0.0
+ * @since 2.0.0
  */
 export declare const Equivalence: Equ.Equivalence<bigint>;
 /**
@@ -396,16 +390,16 @@ export declare const Equivalence: Equ.Equivalence<bigint>;
  * **Example** (Checking less-than comparisons)
  *
  * ```ts
- * import { isLessThan } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThan(2n, 3n), true)
- * assert.deepStrictEqual(isLessThan(3n, 3n), false)
- * assert.deepStrictEqual(isLessThan(4n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isLessThan: {
     /**
@@ -414,16 +408,16 @@ export declare const isLessThan: {
      * **Example** (Checking less-than comparisons)
      *
      * ```ts
-     * import { isLessThan } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThan(2n, 3n), true)
-     * assert.deepStrictEqual(isLessThan(3n, 3n), false)
-     * assert.deepStrictEqual(isLessThan(4n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: bigint): (self: bigint) => boolean;
     /**
@@ -432,16 +426,16 @@ export declare const isLessThan: {
      * **Example** (Checking less-than comparisons)
      *
      * ```ts
-     * import { isLessThan } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThan(2n, 3n), true)
-     * assert.deepStrictEqual(isLessThan(3n, 3n), false)
-     * assert.deepStrictEqual(isLessThan(4n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isLessThan(2n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isLessThan(3n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isLessThan(4n, 3n), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: bigint, that: bigint): boolean;
 };
@@ -451,16 +445,16 @@ export declare const isLessThan: {
  * **Example** (Checking less-than-or-equal comparisons)
  *
  * ```ts
- * import { isLessThanOrEqualTo } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThanOrEqualTo(2n, 3n), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(3n, 3n), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(4n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isLessThanOrEqualTo: {
     /**
@@ -469,16 +463,16 @@ export declare const isLessThanOrEqualTo: {
      * **Example** (Checking less-than-or-equal comparisons)
      *
      * ```ts
-     * import { isLessThanOrEqualTo } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThanOrEqualTo(2n, 3n), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(3n, 3n), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(4n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: bigint): (self: bigint) => boolean;
     /**
@@ -487,16 +481,16 @@ export declare const isLessThanOrEqualTo: {
      * **Example** (Checking less-than-or-equal comparisons)
      *
      * ```ts
-     * import { isLessThanOrEqualTo } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThanOrEqualTo(2n, 3n), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(3n, 3n), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(4n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(2n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(3n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isLessThanOrEqualTo(4n, 3n), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: bigint, that: bigint): boolean;
 };
@@ -506,16 +500,16 @@ export declare const isLessThanOrEqualTo: {
  * **Example** (Checking greater-than comparisons)
  *
  * ```ts
- * import { isGreaterThan } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThan(2n, 3n), false)
- * assert.deepStrictEqual(isGreaterThan(3n, 3n), false)
- * assert.deepStrictEqual(isGreaterThan(4n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isGreaterThan: {
     /**
@@ -524,16 +518,16 @@ export declare const isGreaterThan: {
      * **Example** (Checking greater-than comparisons)
      *
      * ```ts
-     * import { isGreaterThan } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThan(2n, 3n), false)
-     * assert.deepStrictEqual(isGreaterThan(3n, 3n), false)
-     * assert.deepStrictEqual(isGreaterThan(4n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: bigint): (self: bigint) => boolean;
     /**
@@ -542,16 +536,16 @@ export declare const isGreaterThan: {
      * **Example** (Checking greater-than comparisons)
      *
      * ```ts
-     * import { isGreaterThan } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThan(2n, 3n), false)
-     * assert.deepStrictEqual(isGreaterThan(3n, 3n), false)
-     * assert.deepStrictEqual(isGreaterThan(4n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isGreaterThan(2n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isGreaterThan(3n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isGreaterThan(4n, 3n), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: bigint, that: bigint): boolean;
 };
@@ -561,16 +555,16 @@ export declare const isGreaterThan: {
  * **Example** (Checking greater-than-or-equal comparisons)
  *
  * ```ts
- * import { isGreaterThanOrEqualTo } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(2n, 3n), false)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(3n, 3n), true)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(4n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
+ * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualTo: {
     /**
@@ -579,16 +573,16 @@ export declare const isGreaterThanOrEqualTo: {
      * **Example** (Checking greater-than-or-equal comparisons)
      *
      * ```ts
-     * import { isGreaterThanOrEqualTo } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(2n, 3n), false)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(3n, 3n), true)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(4n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: bigint): (self: bigint) => boolean;
     /**
@@ -597,16 +591,16 @@ export declare const isGreaterThanOrEqualTo: {
      * **Example** (Checking greater-than-or-equal comparisons)
      *
      * ```ts
-     * import { isGreaterThanOrEqualTo } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(2n, 3n), false)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(3n, 3n), true)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(4n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(2n, 3n), false)
+     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(3n, 3n), true)
+     * assert.deepStrictEqual(BigInt.isGreaterThanOrEqualTo(4n, 3n), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: bigint, that: bigint): boolean;
 };
@@ -616,7 +610,7 @@ export declare const isGreaterThanOrEqualTo: {
  * **Example** (Checking whether a bigint is within bounds)
  *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
  * const between = BigInt.between({ minimum: 0n, maximum: 5n })
@@ -636,7 +630,7 @@ export declare const between: {
      * **Example** (Checking whether a bigint is within bounds)
      *
      * ```ts
-     * import * as BigInt from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
      * const between = BigInt.between({ minimum: 0n, maximum: 5n })
@@ -659,7 +653,7 @@ export declare const between: {
      * **Example** (Checking whether a bigint is within bounds)
      *
      * ```ts
-     * import * as BigInt from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
      * const between = BigInt.between({ minimum: 0n, maximum: 5n })
@@ -687,7 +681,7 @@ export declare const between: {
  * **Example** (Clamping a bigint to bounds)
  *
  * ```ts
- * import * as BigInt from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
  * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
@@ -711,7 +705,7 @@ export declare const clamp: {
      * **Example** (Clamping a bigint to bounds)
      *
      * ```ts
-     * import * as BigInt from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
      * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
@@ -738,7 +732,7 @@ export declare const clamp: {
      * **Example** (Clamping a bigint to bounds)
      *
      * ```ts
-     * import * as BigInt from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
      * const clamp = BigInt.clamp({ minimum: 1n, maximum: 5n })
@@ -762,10 +756,10 @@ export declare const clamp: {
  * **Example** (Finding the minimum bigint)
  *
  * ```ts
- * import { min } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(min(2n, 3n), 2n)
+ * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
  * ```
  *
  * @category math
@@ -778,10 +772,10 @@ export declare const min: {
      * **Example** (Finding the minimum bigint)
      *
      * ```ts
-     * import { min } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(min(2n, 3n), 2n)
+     * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
      * ```
      *
      * @category math
@@ -794,10 +788,10 @@ export declare const min: {
      * **Example** (Finding the minimum bigint)
      *
      * ```ts
-     * import { min } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(min(2n, 3n), 2n)
+     * assert.deepStrictEqual(BigInt.min(2n, 3n), 2n)
      * ```
      *
      * @category math
@@ -811,10 +805,10 @@ export declare const min: {
  * **Example** (Finding the maximum bigint)
  *
  * ```ts
- * import { max } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(max(2n, 3n), 3n)
+ * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
  * ```
  *
  * @category math
@@ -827,10 +821,10 @@ export declare const max: {
      * **Example** (Finding the maximum bigint)
      *
      * ```ts
-     * import { max } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(max(2n, 3n), 3n)
+     * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
      * ```
      *
      * @category math
@@ -843,10 +837,10 @@ export declare const max: {
      * **Example** (Finding the maximum bigint)
      *
      * ```ts
-     * import { max } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(max(2n, 3n), 3n)
+     * assert.deepStrictEqual(BigInt.max(2n, 3n), 3n)
      * ```
      *
      * @category math
@@ -860,12 +854,12 @@ export declare const max: {
  * **Example** (Determining bigint signs)
  *
  * ```ts
- * import { sign } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sign(-5n), -1)
- * assert.deepStrictEqual(sign(0n), 0)
- * assert.deepStrictEqual(sign(5n), 1)
+ * assert.deepStrictEqual(BigInt.sign(-5n), -1)
+ * assert.deepStrictEqual(BigInt.sign(0n), 0)
+ * assert.deepStrictEqual(BigInt.sign(5n), 1)
  * ```
  *
  * @category math
@@ -878,12 +872,12 @@ export declare const sign: (n: bigint) => Ordering;
  * **Example** (Calculating absolute values)
  *
  * ```ts
- * import { abs } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(abs(-5n), 5n)
- * assert.deepStrictEqual(abs(0n), 0n)
- * assert.deepStrictEqual(abs(5n), 5n)
+ * assert.deepStrictEqual(BigInt.abs(-5n), 5n)
+ * assert.deepStrictEqual(BigInt.abs(0n), 0n)
+ * assert.deepStrictEqual(BigInt.abs(5n), 5n)
  * ```
  *
  * @category math
@@ -896,12 +890,12 @@ export declare const abs: (n: bigint) => bigint;
  * **Example** (Calculating greatest common divisors)
  *
  * ```ts
- * import { gcd } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(gcd(2n, 3n), 1n)
- * assert.deepStrictEqual(gcd(2n, 4n), 2n)
- * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+ * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
+ * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
+ * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
  * ```
  *
  * @category math
@@ -914,12 +908,12 @@ export declare const gcd: {
      * **Example** (Calculating greatest common divisors)
      *
      * ```ts
-     * import { gcd } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(gcd(2n, 3n), 1n)
-     * assert.deepStrictEqual(gcd(2n, 4n), 2n)
-     * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+     * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
+     * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
+     * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
      * ```
      *
      * @category math
@@ -932,12 +926,12 @@ export declare const gcd: {
      * **Example** (Calculating greatest common divisors)
      *
      * ```ts
-     * import { gcd } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(gcd(2n, 3n), 1n)
-     * assert.deepStrictEqual(gcd(2n, 4n), 2n)
-     * assert.deepStrictEqual(gcd(16n, 24n), 8n)
+     * assert.deepStrictEqual(BigInt.gcd(2n, 3n), 1n)
+     * assert.deepStrictEqual(BigInt.gcd(2n, 4n), 2n)
+     * assert.deepStrictEqual(BigInt.gcd(16n, 24n), 8n)
      * ```
      *
      * @category math
@@ -951,12 +945,12 @@ export declare const gcd: {
  * **Example** (Calculating least common multiples)
  *
  * ```ts
- * import { lcm } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(lcm(2n, 3n), 6n)
- * assert.deepStrictEqual(lcm(2n, 4n), 4n)
- * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+ * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
+ * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
+ * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
  * ```
  *
  * @category math
@@ -969,12 +963,12 @@ export declare const lcm: {
      * **Example** (Calculating least common multiples)
      *
      * ```ts
-     * import { lcm } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(lcm(2n, 3n), 6n)
-     * assert.deepStrictEqual(lcm(2n, 4n), 4n)
-     * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+     * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
+     * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
+     * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
      * ```
      *
      * @category math
@@ -987,12 +981,12 @@ export declare const lcm: {
      * **Example** (Calculating least common multiples)
      *
      * ```ts
-     * import { lcm } from "effect/BigInt"
+     * import { BigInt } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(lcm(2n, 3n), 6n)
-     * assert.deepStrictEqual(lcm(2n, 4n), 4n)
-     * assert.deepStrictEqual(lcm(16n, 24n), 48n)
+     * assert.deepStrictEqual(BigInt.lcm(2n, 3n), 6n)
+     * assert.deepStrictEqual(BigInt.lcm(2n, 4n), 4n)
+     * assert.deepStrictEqual(BigInt.lcm(16n, 24n), 48n)
      * ```
      *
      * @category math
@@ -1009,16 +1003,16 @@ export declare const lcm: {
  * **Example** (Calculating square roots unsafely)
  *
  * ```ts
- * import { sqrtUnsafe } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sqrtUnsafe(4n), 2n)
- * assert.deepStrictEqual(sqrtUnsafe(9n), 3n)
- * assert.deepStrictEqual(sqrtUnsafe(16n), 4n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(4n), 2n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(9n), 3n)
+ * assert.deepStrictEqual(BigInt.sqrtUnsafe(16n), 4n)
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const sqrtUnsafe: (n: bigint) => bigint;
 /**
@@ -1051,10 +1045,10 @@ export declare const sqrt: (n: bigint) => Option.Option<bigint>;
  * **Example** (Summing iterable bigints)
  *
  * ```ts
- * import { sumAll } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sumAll([2n, 3n, 4n]), 9n)
+ * assert.deepStrictEqual(BigInt.sumAll([2n, 3n, 4n]), 9n)
  * ```
  *
  * @category math
@@ -1070,10 +1064,10 @@ export declare const sumAll: (collection: Iterable<bigint>) => bigint;
  * **Example** (Multiplying iterable bigints)
  *
  * ```ts
- * import { multiplyAll } from "effect/BigInt"
+ * import { BigInt } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiplyAll([2n, 3n, 4n]), 24n)
+ * assert.deepStrictEqual(BigInt.multiplyAll([2n, 3n, 4n]), 24n)
  * ```
  *
  * @category math
@@ -1096,7 +1090,7 @@ export declare const multiplyAll: (collection: Iterable<bigint>) => bigint;
  * BI.toNumber(BigInt(Number.MIN_SAFE_INTEGER) - 1n) // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.0.0
  */
 export declare const toNumber: (b: bigint) => Option.Option<number>;
@@ -1116,7 +1110,7 @@ export declare const toNumber: (b: bigint) => Option.Option<number>;
  * BigInt.fromString("a") // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.4.12
  */
 export declare const fromString: (s: string) => Option.Option<bigint>;
@@ -1138,7 +1132,7 @@ export declare const fromString: (s: string) => Option.Option<bigint>;
  * BigInt.fromNumber(Number.MIN_SAFE_INTEGER - 1) // Option.none()
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.4.12
  */
 export declare function fromNumber(n: number): Option.Option<bigint>;
@@ -1206,24 +1200,28 @@ export declare const remainder: {
 /**
  * A `Reducer` for combining `bigint`s using addition.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerSum: Reducer.Reducer<bigint>;
 /**
  * A `Reducer` for combining `bigint`s using multiplication.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerMultiply: Reducer.Reducer<bigint>;
 /**
  * A `Combiner` that returns the maximum `bigint`.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const CombinerMax: Combiner.Combiner<bigint>;
 /**
  * A `Combiner` that returns the minimum `bigint`.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const CombinerMin: Combiner.Combiner<bigint>;