effect 4.0.0-beta.67 → 4.0.0-beta.68

package/src/BigDecimal.ts

@@ -159,16 +159,16 @@ const one = makeNormalizedUnsafe(bigint1, 0)
  * **Example** (Normalizing trailing zeros)
  *
  * ```ts
- * import { fromStringUnsafe, make, normalize } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   normalize(fromStringUnsafe("123.00000")),
- *   normalize(make(123n, 0))
+ *   BigDecimal.normalize(BigDecimal.fromStringUnsafe("123.00000")),
+ *   BigDecimal.normalize(BigDecimal.make(123n, 0))
  * )
  * assert.deepStrictEqual(
- *   normalize(fromStringUnsafe("12300000")),
- *   normalize(make(123n, -5))
+ *   BigDecimal.normalize(BigDecimal.fromStringUnsafe("12300000")),
+ *   BigDecimal.normalize(BigDecimal.make(123n, -5))
  * )
  * ```
  *
@@ -303,12 +303,12 @@ export const scale: {
  * **Example** (Adding decimals)
  *
  * ```ts
- * import { fromStringUnsafe, sum } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   sum(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("5")
+ *   BigDecimal.sum(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("5")
  * )
  * ```
  *
@@ -322,12 +322,12 @@ export const sum: {
    * **Example** (Adding decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, sum } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   sum(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("5")
+   *   BigDecimal.sum(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("5")
    * )
    * ```
    *
@@ -341,12 +341,12 @@ export const sum: {
    * **Example** (Adding decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, sum } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   sum(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("5")
+   *   BigDecimal.sum(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("5")
    * )
    * ```
    *
@@ -380,17 +380,17 @@ export const sum: {
  * **Example** (Adding multiple decimals)
  *
  * ```ts
- * import { fromStringUnsafe, sumAll } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   sumAll([fromStringUnsafe("2"), fromStringUnsafe("3"), fromStringUnsafe("4")]),
- *   fromStringUnsafe("9")
+ *   BigDecimal.sumAll([BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("4")]),
+ *   BigDecimal.fromStringUnsafe("9")
  * )
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const sumAll = (collection: Iterable<BigDecimal>): BigDecimal => {
   let out: BigDecimal = zero
@@ -406,12 +406,12 @@ export const sumAll = (collection: Iterable<BigDecimal>): BigDecimal => {
  * **Example** (Multiplying decimals)
  *
  * ```ts
- * import { fromStringUnsafe, multiply } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   multiply(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("6")
+ *   BigDecimal.multiply(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("6")
  * )
  * ```
  *
@@ -425,12 +425,12 @@ export const multiply: {
    * **Example** (Multiplying decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, multiply } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   multiply(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("6")
+   *   BigDecimal.multiply(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("6")
    * )
    * ```
    *
@@ -444,12 +444,12 @@ export const multiply: {
    * **Example** (Multiplying decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, multiply } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   multiply(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("6")
+   *   BigDecimal.multiply(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("6")
    * )
    * ```
    *
@@ -471,12 +471,12 @@ export const multiply: {
  * **Example** (Multiplying multiple decimals)
  *
  * ```ts
- * import { fromStringUnsafe, multiplyAll } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   multiplyAll([fromStringUnsafe("2"), fromStringUnsafe("3"), fromStringUnsafe("4")]),
- *   fromStringUnsafe("24")
+ *   BigDecimal.multiplyAll([BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("4")]),
+ *   BigDecimal.fromStringUnsafe("24")
  * )
  * ```
  *
@@ -500,12 +500,12 @@ export const multiplyAll = (collection: Iterable<BigDecimal>): BigDecimal => {
  * **Example** (Subtracting decimals)
  *
  * ```ts
- * import { fromStringUnsafe, subtract } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   subtract(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("-1")
+ *   BigDecimal.subtract(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("-1")
  * )
  * ```
  *
@@ -519,12 +519,12 @@ export const subtract: {
    * **Example** (Subtracting decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, subtract } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   subtract(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("-1")
+   *   BigDecimal.subtract(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("-1")
    * )
    * ```
    *
@@ -538,12 +538,12 @@ export const subtract: {
    * **Example** (Subtracting decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, subtract } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   subtract(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("-1")
+   *   BigDecimal.subtract(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("-1")
    * )
    * ```
    *
@@ -796,14 +796,14 @@ export const divide: {
  * **Example** (Dividing decimals unsafely)
  *
  * ```ts
- * import { divideUnsafe, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  *
- * console.log(divideUnsafe(fromStringUnsafe("6"), fromStringUnsafe("3"))) // BigDecimal(2)
- * console.log(divideUnsafe(fromStringUnsafe("6"), fromStringUnsafe("4"))) // BigDecimal(1.5)
+ * console.log(BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("3"))) // BigDecimal(2)
+ * console.log(BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("4"))) // BigDecimal(1.5)
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const divideUnsafe: {
   /**
@@ -817,14 +817,14 @@ export const divideUnsafe: {
    * **Example** (Dividing decimals unsafely)
    *
    * ```ts
-   * import { divideUnsafe, fromStringUnsafe } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    *
-   * console.log(divideUnsafe(fromStringUnsafe("6"), fromStringUnsafe("3"))) // BigDecimal(2)
-   * console.log(divideUnsafe(fromStringUnsafe("6"), fromStringUnsafe("4"))) // BigDecimal(1.5)
+   * console.log(BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("3"))) // BigDecimal(2)
+   * console.log(BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("4"))) // BigDecimal(1.5)
    * ```
    *
    * @category math
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: BigDecimal): (self: BigDecimal) => BigDecimal
   /**
@@ -838,14 +838,14 @@ export const divideUnsafe: {
    * **Example** (Dividing decimals unsafely)
    *
    * ```ts
-   * import { divideUnsafe, fromStringUnsafe } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    *
-   * console.log(divideUnsafe(fromStringUnsafe("6"), fromStringUnsafe("3"))) // BigDecimal(2)
-   * console.log(divideUnsafe(fromStringUnsafe("6"), fromStringUnsafe("4"))) // BigDecimal(1.5)
+   * console.log(BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("3"))) // BigDecimal(2)
+   * console.log(BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("4"))) // BigDecimal(1.5)
    * ```
    *
    * @category math
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: BigDecimal, that: BigDecimal): BigDecimal
 } = dual(2, (self: BigDecimal, that: BigDecimal): BigDecimal => {
@@ -907,25 +907,25 @@ export const Order: order.Order<BigDecimal> = order.make((self, that) => {
  * **Example** (Checking less-than comparisons)
  *
  * ```ts
- * import { fromStringUnsafe, isLessThan } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   isLessThan(fromStringUnsafe("2"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * assert.deepStrictEqual(
- *   isLessThan(fromStringUnsafe("3"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * assert.deepStrictEqual(
- *   isLessThan(fromStringUnsafe("4"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isLessThan: {
   /**
@@ -934,25 +934,25 @@ export const isLessThan: {
    * **Example** (Checking less-than comparisons)
    *
    * ```ts
-   * import { fromStringUnsafe, isLessThan } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   isLessThan(fromStringUnsafe("2"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * assert.deepStrictEqual(
-   *   isLessThan(fromStringUnsafe("3"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * assert.deepStrictEqual(
-   *   isLessThan(fromStringUnsafe("4"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: BigDecimal): (self: BigDecimal) => boolean
   /**
@@ -961,25 +961,25 @@ export const isLessThan: {
    * **Example** (Checking less-than comparisons)
    *
    * ```ts
-   * import { fromStringUnsafe, isLessThan } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   isLessThan(fromStringUnsafe("2"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * assert.deepStrictEqual(
-   *   isLessThan(fromStringUnsafe("3"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * assert.deepStrictEqual(
-   *   isLessThan(fromStringUnsafe("4"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: BigDecimal, that: BigDecimal): boolean
 } = order.isLessThan(Order)
@@ -990,25 +990,25 @@ export const isLessThan: {
  * **Example** (Checking less-than-or-equal comparisons)
  *
  * ```ts
- * import { fromStringUnsafe, isLessThanOrEqualTo } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   isLessThanOrEqualTo(fromStringUnsafe("2"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * assert.deepStrictEqual(
- *   isLessThanOrEqualTo(fromStringUnsafe("3"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * assert.deepStrictEqual(
- *   isLessThanOrEqualTo(fromStringUnsafe("4"), fromStringUnsafe("3")),
+ *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isLessThanOrEqualTo: {
   /**
@@ -1017,25 +1017,25 @@ export const isLessThanOrEqualTo: {
    * **Example** (Checking less-than-or-equal comparisons)
    *
    * ```ts
-   * import { fromStringUnsafe, isLessThanOrEqualTo } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   isLessThanOrEqualTo(fromStringUnsafe("2"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * assert.deepStrictEqual(
-   *   isLessThanOrEqualTo(fromStringUnsafe("3"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * assert.deepStrictEqual(
-   *   isLessThanOrEqualTo(fromStringUnsafe("4"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: BigDecimal): (self: BigDecimal) => boolean
   /**
@@ -1044,25 +1044,25 @@ export const isLessThanOrEqualTo: {
    * **Example** (Checking less-than-or-equal comparisons)
    *
    * ```ts
-   * import { fromStringUnsafe, isLessThanOrEqualTo } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   isLessThanOrEqualTo(fromStringUnsafe("2"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * assert.deepStrictEqual(
-   *   isLessThanOrEqualTo(fromStringUnsafe("3"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * assert.deepStrictEqual(
-   *   isLessThanOrEqualTo(fromStringUnsafe("4"), fromStringUnsafe("3")),
+   *   BigDecimal.isLessThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: BigDecimal, that: BigDecimal): boolean
 } = order.isLessThanOrEqualTo(Order)
@@ -1073,25 +1073,25 @@ export const isLessThanOrEqualTo: {
  * **Example** (Checking greater-than comparisons)
  *
  * ```ts
- * import { fromStringUnsafe, isGreaterThan } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   isGreaterThan(fromStringUnsafe("2"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * assert.deepStrictEqual(
- *   isGreaterThan(fromStringUnsafe("3"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * assert.deepStrictEqual(
- *   isGreaterThan(fromStringUnsafe("4"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isGreaterThan: {
   /**
@@ -1100,25 +1100,25 @@ export const isGreaterThan: {
    * **Example** (Checking greater-than comparisons)
    *
    * ```ts
-   * import { fromStringUnsafe, isGreaterThan } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   isGreaterThan(fromStringUnsafe("2"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * assert.deepStrictEqual(
-   *   isGreaterThan(fromStringUnsafe("3"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * assert.deepStrictEqual(
-   *   isGreaterThan(fromStringUnsafe("4"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: BigDecimal): (self: BigDecimal) => boolean
   /**
@@ -1127,25 +1127,25 @@ export const isGreaterThan: {
    * **Example** (Checking greater-than comparisons)
    *
    * ```ts
-   * import { fromStringUnsafe, isGreaterThan } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   isGreaterThan(fromStringUnsafe("2"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * assert.deepStrictEqual(
-   *   isGreaterThan(fromStringUnsafe("3"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * assert.deepStrictEqual(
-   *   isGreaterThan(fromStringUnsafe("4"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThan(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: BigDecimal, that: BigDecimal): boolean
 } = order.isGreaterThan(Order)
@@ -1156,25 +1156,25 @@ export const isGreaterThan: {
  * **Example** (Checking greater-than-or-equal comparisons)
  *
  * ```ts
- * import { fromStringUnsafe, isGreaterThanOrEqualTo } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   isGreaterThanOrEqualTo(fromStringUnsafe("2"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
  *   false
  * )
  * assert.deepStrictEqual(
- *   isGreaterThanOrEqualTo(fromStringUnsafe("3"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * assert.deepStrictEqual(
- *   isGreaterThanOrEqualTo(fromStringUnsafe("4"), fromStringUnsafe("3")),
+ *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
  *   true
  * )
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const isGreaterThanOrEqualTo: {
   /**
@@ -1183,25 +1183,25 @@ export const isGreaterThanOrEqualTo: {
    * **Example** (Checking greater-than-or-equal comparisons)
    *
    * ```ts
-   * import { fromStringUnsafe, isGreaterThanOrEqualTo } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   isGreaterThanOrEqualTo(fromStringUnsafe("2"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * assert.deepStrictEqual(
-   *   isGreaterThanOrEqualTo(fromStringUnsafe("3"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * assert.deepStrictEqual(
-   *   isGreaterThanOrEqualTo(fromStringUnsafe("4"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (that: BigDecimal): (self: BigDecimal) => boolean
   /**
@@ -1210,25 +1210,25 @@ export const isGreaterThanOrEqualTo: {
    * **Example** (Checking greater-than-or-equal comparisons)
    *
    * ```ts
-   * import { fromStringUnsafe, isGreaterThanOrEqualTo } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   isGreaterThanOrEqualTo(fromStringUnsafe("2"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
    *   false
    * )
    * assert.deepStrictEqual(
-   *   isGreaterThanOrEqualTo(fromStringUnsafe("3"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * assert.deepStrictEqual(
-   *   isGreaterThanOrEqualTo(fromStringUnsafe("4"), fromStringUnsafe("3")),
+   *   BigDecimal.isGreaterThanOrEqualTo(BigDecimal.fromStringUnsafe("4"), BigDecimal.fromStringUnsafe("3")),
    *   true
    * )
    * ```
    *
    * @category predicates
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: BigDecimal, that: BigDecimal): boolean
 } = order.isGreaterThanOrEqualTo(Order)
@@ -1442,12 +1442,12 @@ export const clamp: {
  * **Example** (Selecting the smaller decimal)
  *
  * ```ts
- * import { fromStringUnsafe, min } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   min(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("2")
+ *   BigDecimal.min(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("2")
  * )
  * ```
  *
@@ -1461,12 +1461,12 @@ export const min: {
    * **Example** (Selecting the smaller decimal)
    *
    * ```ts
-   * import { fromStringUnsafe, min } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   min(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("2")
+   *   BigDecimal.min(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("2")
    * )
    * ```
    *
@@ -1480,12 +1480,12 @@ export const min: {
    * **Example** (Selecting the smaller decimal)
    *
    * ```ts
-   * import { fromStringUnsafe, min } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   min(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("2")
+   *   BigDecimal.min(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("2")
    * )
    * ```
    *
@@ -1501,12 +1501,12 @@ export const min: {
  * **Example** (Selecting the larger decimal)
  *
  * ```ts
- * import { fromStringUnsafe, max } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   max(fromStringUnsafe("2"), fromStringUnsafe("3")),
- *   fromStringUnsafe("3")
+ *   BigDecimal.max(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+ *   BigDecimal.fromStringUnsafe("3")
  * )
  * ```
  *
@@ -1520,12 +1520,12 @@ export const max: {
    * **Example** (Selecting the larger decimal)
    *
    * ```ts
-   * import { fromStringUnsafe, max } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   max(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("3")
+   *   BigDecimal.max(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("3")
    * )
    * ```
    *
@@ -1539,12 +1539,12 @@ export const max: {
    * **Example** (Selecting the larger decimal)
    *
    * ```ts
-   * import { fromStringUnsafe, max } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   max(fromStringUnsafe("2"), fromStringUnsafe("3")),
-   *   fromStringUnsafe("3")
+   *   BigDecimal.max(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("3")),
+   *   BigDecimal.fromStringUnsafe("3")
    * )
    * ```
    *
@@ -1560,12 +1560,12 @@ export const max: {
  * **Example** (Reading decimal signs)
  *
  * ```ts
- * import { fromStringUnsafe, sign } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sign(fromStringUnsafe("-5")), -1)
- * assert.deepStrictEqual(sign(fromStringUnsafe("0")), 0)
- * assert.deepStrictEqual(sign(fromStringUnsafe("5")), 1)
+ * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("-5")), -1)
+ * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("0")), 0)
+ * assert.deepStrictEqual(BigDecimal.sign(BigDecimal.fromStringUnsafe("5")), 1)
  * ```
  *
  * @category math
@@ -1579,12 +1579,12 @@ export const sign = (n: BigDecimal): Ordering => n.value === bigint0 ? 0 : n.val
  * **Example** (Calculating absolute values)
  *
  * ```ts
- * import { abs, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(abs(fromStringUnsafe("-5")), fromStringUnsafe("5"))
- * assert.deepStrictEqual(abs(fromStringUnsafe("0")), fromStringUnsafe("0"))
- * assert.deepStrictEqual(abs(fromStringUnsafe("5")), fromStringUnsafe("5"))
+ * assert.deepStrictEqual(BigDecimal.abs(BigDecimal.fromStringUnsafe("-5")), BigDecimal.fromStringUnsafe("5"))
+ * assert.deepStrictEqual(BigDecimal.abs(BigDecimal.fromStringUnsafe("0")), BigDecimal.fromStringUnsafe("0"))
+ * assert.deepStrictEqual(BigDecimal.abs(BigDecimal.fromStringUnsafe("5")), BigDecimal.fromStringUnsafe("5"))
  * ```
  *
  * @category math
@@ -1598,11 +1598,11 @@ export const abs = (n: BigDecimal): BigDecimal => n.value < bigint0 ? make(-n.va
  * **Example** (Negating decimals)
  *
  * ```ts
- * import { fromStringUnsafe, negate } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(negate(fromStringUnsafe("3")), fromStringUnsafe("-3"))
- * assert.deepStrictEqual(negate(fromStringUnsafe("-6")), fromStringUnsafe("6"))
+ * assert.deepStrictEqual(BigDecimal.negate(BigDecimal.fromStringUnsafe("3")), BigDecimal.fromStringUnsafe("-3"))
+ * assert.deepStrictEqual(BigDecimal.negate(BigDecimal.fromStringUnsafe("-6")), BigDecimal.fromStringUnsafe("6"))
  * ```
  *
  * @category math
@@ -1741,25 +1741,25 @@ export const remainder: {
  * **Example** (Computing remainders unsafely)
  *
  * ```ts
- * import { fromStringUnsafe, remainderUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   remainderUnsafe(fromStringUnsafe("2"), fromStringUnsafe("2")),
- *   fromStringUnsafe("0")
+ *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("2")),
+ *   BigDecimal.fromStringUnsafe("0")
  * )
  * assert.deepStrictEqual(
- *   remainderUnsafe(fromStringUnsafe("3"), fromStringUnsafe("2")),
- *   fromStringUnsafe("1")
+ *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("2")),
+ *   BigDecimal.fromStringUnsafe("1")
  * )
  * assert.deepStrictEqual(
- *   remainderUnsafe(fromStringUnsafe("-4"), fromStringUnsafe("2")),
- *   fromStringUnsafe("0")
+ *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("-4"), BigDecimal.fromStringUnsafe("2")),
+ *   BigDecimal.fromStringUnsafe("0")
  * )
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const remainderUnsafe: {
   /**
@@ -1770,25 +1770,25 @@ export const remainderUnsafe: {
    * **Example** (Computing remainders unsafely)
    *
    * ```ts
-   * import { fromStringUnsafe, remainderUnsafe } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   remainderUnsafe(fromStringUnsafe("2"), fromStringUnsafe("2")),
-   *   fromStringUnsafe("0")
+   *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("2")),
+   *   BigDecimal.fromStringUnsafe("0")
    * )
    * assert.deepStrictEqual(
-   *   remainderUnsafe(fromStringUnsafe("3"), fromStringUnsafe("2")),
-   *   fromStringUnsafe("1")
+   *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("2")),
+   *   BigDecimal.fromStringUnsafe("1")
    * )
    * assert.deepStrictEqual(
-   *   remainderUnsafe(fromStringUnsafe("-4"), fromStringUnsafe("2")),
-   *   fromStringUnsafe("0")
+   *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("-4"), BigDecimal.fromStringUnsafe("2")),
+   *   BigDecimal.fromStringUnsafe("0")
    * )
    * ```
    *
    * @category math
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (divisor: BigDecimal): (self: BigDecimal) => BigDecimal
   /**
@@ -1799,25 +1799,25 @@ export const remainderUnsafe: {
    * **Example** (Computing remainders unsafely)
    *
    * ```ts
-   * import { fromStringUnsafe, remainderUnsafe } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   remainderUnsafe(fromStringUnsafe("2"), fromStringUnsafe("2")),
-   *   fromStringUnsafe("0")
+   *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("2"), BigDecimal.fromStringUnsafe("2")),
+   *   BigDecimal.fromStringUnsafe("0")
    * )
    * assert.deepStrictEqual(
-   *   remainderUnsafe(fromStringUnsafe("3"), fromStringUnsafe("2")),
-   *   fromStringUnsafe("1")
+   *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("3"), BigDecimal.fromStringUnsafe("2")),
+   *   BigDecimal.fromStringUnsafe("1")
    * )
    * assert.deepStrictEqual(
-   *   remainderUnsafe(fromStringUnsafe("-4"), fromStringUnsafe("2")),
-   *   fromStringUnsafe("0")
+   *   BigDecimal.remainderUnsafe(BigDecimal.fromStringUnsafe("-4"), BigDecimal.fromStringUnsafe("2")),
+   *   BigDecimal.fromStringUnsafe("0")
    * )
    * ```
    *
    * @category math
-   * @since 2.0.0
+   * @since 4.0.0
    */
   (self: BigDecimal, divisor: BigDecimal): BigDecimal
 } = dual(2, (self: BigDecimal, divisor: BigDecimal): BigDecimal => {
@@ -1953,11 +1953,11 @@ export const fromBigInt = (n: bigint): BigDecimal => make(n, 0)
  * **Example** (Creating decimals from finite numbers)
  *
  * ```ts
- * import { fromNumberUnsafe, make } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(fromNumberUnsafe(123), make(123n, 0))
- * assert.deepStrictEqual(fromNumberUnsafe(123.456), make(123456n, 3))
+ * assert.deepStrictEqual(BigDecimal.fromNumberUnsafe(123), BigDecimal.make(123n, 0))
+ * assert.deepStrictEqual(BigDecimal.fromNumberUnsafe(123.456), BigDecimal.make(123456n, 3))
  * ```
  *
  * @category constructors
@@ -1990,7 +1990,7 @@ export const fromNumberUnsafe = (n: number): BigDecimal => {
  * ```
  *
  * @category constructors
- * @since 4.0.0
+ * @since 2.0.0
  */
 export const fromNumber = (n: number): Option.Option<BigDecimal> => {
   if (!Number.isFinite(n)) {
@@ -2085,16 +2085,16 @@ export const fromString = (s: string): Option.Option<BigDecimal> => {
  * **Example** (Parsing decimal strings unsafely)
  *
  * ```ts
- * import { fromStringUnsafe, make } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(fromStringUnsafe("123"), make(123n, 0))
- * assert.deepStrictEqual(fromStringUnsafe("123.456"), make(123456n, 3))
- * assert.throws(() => fromStringUnsafe("123.abc"))
+ * assert.deepStrictEqual(BigDecimal.fromStringUnsafe("123"), BigDecimal.make(123n, 0))
+ * assert.deepStrictEqual(BigDecimal.fromStringUnsafe("123.456"), BigDecimal.make(123456n, 3))
+ * assert.throws(() => BigDecimal.fromStringUnsafe("123.abc"))
  * ```
  *
  * @category constructors
- * @since 2.0.0
+ * @since 4.0.0
  */
 export const fromStringUnsafe = (s: string): BigDecimal => {
   return Option.getOrThrowWith(fromString(s), () => new Error(`Invalid numerical string: ${s}`))
@@ -2110,15 +2110,15 @@ export const fromStringUnsafe = (s: string): BigDecimal => {
  * **Example** (Formatting decimals)
  *
  * ```ts
- * import { format, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(format(fromStringUnsafe("-5")), "-5")
- * assert.deepStrictEqual(format(fromStringUnsafe("123.456")), "123.456")
- * assert.deepStrictEqual(format(fromStringUnsafe("-0.00000123")), "-0.00000123")
+ * assert.deepStrictEqual(BigDecimal.format(BigDecimal.fromStringUnsafe("-5")), "-5")
+ * assert.deepStrictEqual(BigDecimal.format(BigDecimal.fromStringUnsafe("123.456")), "123.456")
+ * assert.deepStrictEqual(BigDecimal.format(BigDecimal.fromStringUnsafe("-0.00000123")), "-0.00000123")
  * ```
  *
- * @category conversions
+ * @category converting
  * @since 2.0.0
  */
 export const format = (n: BigDecimal): string => {
@@ -2158,14 +2158,14 @@ export const format = (n: BigDecimal): string => {
  * **Example** (Formatting decimals exponentially)
  *
  * ```ts
- * import { make, toExponential } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(toExponential(make(123456n, -5)), "1.23456e+10")
+ * assert.deepStrictEqual(BigDecimal.toExponential(BigDecimal.make(123456n, -5)), "1.23456e+10")
  * ```
  *
- * @category conversions
- * @since 4.0.0
+ * @category converting
+ * @since 3.11.0
  */
 export const toExponential = (n: BigDecimal): string => {
   if (isZero(n)) {
@@ -2196,14 +2196,14 @@ export const toExponential = (n: BigDecimal): string => {
  * **Example** (Converting decimals to numbers)
  *
  * ```ts
- * import { fromStringUnsafe, toNumberUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(toNumberUnsafe(fromStringUnsafe("123.456")), 123.456)
+ * assert.deepStrictEqual(BigDecimal.toNumberUnsafe(BigDecimal.fromStringUnsafe("123.456")), 123.456)
  * ```
  *
- * @category conversions
- * @since 2.0.0
+ * @category converting
+ * @since 4.0.0
  */
 export const toNumberUnsafe = (n: BigDecimal): number => Number(format(n))
 
@@ -2213,12 +2213,12 @@ export const toNumberUnsafe = (n: BigDecimal): number => Number(format(n))
  * **Example** (Checking integer decimals)
  *
  * ```ts
- * import { fromStringUnsafe, isInteger } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isInteger(fromStringUnsafe("0")), true)
- * assert.deepStrictEqual(isInteger(fromStringUnsafe("1")), true)
- * assert.deepStrictEqual(isInteger(fromStringUnsafe("1.1")), false)
+ * assert.deepStrictEqual(BigDecimal.isInteger(BigDecimal.fromStringUnsafe("0")), true)
+ * assert.deepStrictEqual(BigDecimal.isInteger(BigDecimal.fromStringUnsafe("1")), true)
+ * assert.deepStrictEqual(BigDecimal.isInteger(BigDecimal.fromStringUnsafe("1.1")), false)
  * ```
  *
  * @category predicates
@@ -2232,11 +2232,11 @@ export const isInteger = (n: BigDecimal): boolean => normalize(n).scale <= 0
  * **Example** (Checking zero decimals)
  *
  * ```ts
- * import { fromStringUnsafe, isZero } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isZero(fromStringUnsafe("0")), true)
- * assert.deepStrictEqual(isZero(fromStringUnsafe("1")), false)
+ * assert.deepStrictEqual(BigDecimal.isZero(BigDecimal.fromStringUnsafe("0")), true)
+ * assert.deepStrictEqual(BigDecimal.isZero(BigDecimal.fromStringUnsafe("1")), false)
  * ```
  *
  * @category predicates
@@ -2250,12 +2250,12 @@ export const isZero = (n: BigDecimal): boolean => n.value === bigint0
  * **Example** (Checking negative decimals)
  *
  * ```ts
- * import { fromStringUnsafe, isNegative } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isNegative(fromStringUnsafe("-1")), true)
- * assert.deepStrictEqual(isNegative(fromStringUnsafe("0")), false)
- * assert.deepStrictEqual(isNegative(fromStringUnsafe("1")), false)
+ * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("-1")), true)
+ * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("0")), false)
+ * assert.deepStrictEqual(BigDecimal.isNegative(BigDecimal.fromStringUnsafe("1")), false)
  * ```
  *
  * @category predicates
@@ -2269,12 +2269,12 @@ export const isNegative = (n: BigDecimal): boolean => n.value < bigint0
  * **Example** (Checking positive decimals)
  *
  * ```ts
- * import { fromStringUnsafe, isPositive } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isPositive(fromStringUnsafe("-1")), false)
- * assert.deepStrictEqual(isPositive(fromStringUnsafe("0")), false)
- * assert.deepStrictEqual(isPositive(fromStringUnsafe("1")), true)
+ * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("-1")), false)
+ * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("0")), false)
+ * assert.deepStrictEqual(BigDecimal.isPositive(BigDecimal.fromStringUnsafe("1")), true)
  * ```
  *
  * @category predicates
@@ -2299,7 +2299,7 @@ const isBigDecimalArgs = (args: IArguments) => isBigDecimal(args[0])
  * `half-odd`: round to the nearest neighbor; if equidistant round to the neighbor with an odd digit
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export type RoundingMode =
   | "ceil"
@@ -2319,21 +2319,21 @@ export type RoundingMode =
  * **Example** (Rounding decimals)
  *
  * ```ts
- * import { fromStringUnsafe, round } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   round(fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
- *   fromStringUnsafe("150")
+ *   BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
+ *   BigDecimal.fromStringUnsafe("150")
  * )
  * assert.deepStrictEqual(
- *   round(fromStringUnsafe("-14.5")),
- *   fromStringUnsafe("-15")
+ *   BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5")),
+ *   BigDecimal.fromStringUnsafe("-15")
  * )
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const round: {
   /**
@@ -2342,21 +2342,21 @@ export const round: {
    * **Example** (Rounding decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, round } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   round(fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
-   *   fromStringUnsafe("150")
+   *   BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
+   *   BigDecimal.fromStringUnsafe("150")
    * )
    * assert.deepStrictEqual(
-   *   round(fromStringUnsafe("-14.5")),
-   *   fromStringUnsafe("-15")
+   *   BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5")),
+   *   BigDecimal.fromStringUnsafe("-15")
    * )
    * ```
    *
    * @category math
-   * @since 4.0.0
+   * @since 3.16.0
    */
   (options: { scale?: number; mode?: RoundingMode }): (self: BigDecimal) => BigDecimal
   /**
@@ -2365,21 +2365,21 @@ export const round: {
    * **Example** (Rounding decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, round } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   round(fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
-   *   fromStringUnsafe("150")
+   *   BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 }),
+   *   BigDecimal.fromStringUnsafe("150")
    * )
    * assert.deepStrictEqual(
-   *   round(fromStringUnsafe("-14.5")),
-   *   fromStringUnsafe("-15")
+   *   BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5")),
+   *   BigDecimal.fromStringUnsafe("-15")
    * )
    * ```
    *
    * @category math
-   * @since 4.0.0
+   * @since 3.16.0
    */
   (n: BigDecimal, options?: { scale?: number; mode?: RoundingMode }): BigDecimal
 } = dual(isBigDecimalArgs, (self: BigDecimal, options?: { scale?: number; mode?: RoundingMode }): BigDecimal => {
@@ -2436,14 +2436,14 @@ export const round: {
  * **Example** (Truncating decimals)
  *
  * ```ts
- * import { fromStringUnsafe, truncate } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  *
- * console.log(truncate(fromStringUnsafe("145"), -1)) // BigDecimal(140)
- * console.log(truncate(fromStringUnsafe("-14.5"))) // BigDecimal(-14)
+ * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1)) // BigDecimal(140)
+ * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5"))) // BigDecimal(-14)
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const truncate: {
   /**
@@ -2453,14 +2453,14 @@ export const truncate: {
    * **Example** (Truncating decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, truncate } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    *
-   * console.log(truncate(fromStringUnsafe("145"), -1)) // BigDecimal(140)
-   * console.log(truncate(fromStringUnsafe("-14.5"))) // BigDecimal(-14)
+   * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1)) // BigDecimal(140)
+   * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5"))) // BigDecimal(-14)
    * ```
    *
    * @category math
-   * @since 4.0.0
+   * @since 3.16.0
    */
   (scale: number): (self: BigDecimal) => BigDecimal
   /**
@@ -2470,14 +2470,14 @@ export const truncate: {
    * **Example** (Truncating decimals)
    *
    * ```ts
-   * import { fromStringUnsafe, truncate } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    *
-   * console.log(truncate(fromStringUnsafe("145"), -1)) // BigDecimal(140)
-   * console.log(truncate(fromStringUnsafe("-14.5"))) // BigDecimal(-14)
+   * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1)) // BigDecimal(140)
+   * console.log(BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5"))) // BigDecimal(-14)
    * ```
    *
    * @category math
-   * @since 4.0.0
+   * @since 3.16.0
    */
   (self: BigDecimal, scale?: number): BigDecimal
 } = dual(isBigDecimalArgs, (self: BigDecimal, scale: number = 0): BigDecimal => {
@@ -2495,18 +2495,18 @@ export const truncate: {
  * **Example** (Rounding decimals up)
  *
  * ```ts
- * import { ceil, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   ceil(fromStringUnsafe("145"), -1),
- *   fromStringUnsafe("150")
+ *   BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1),
+ *   BigDecimal.fromStringUnsafe("150")
  * )
- * assert.deepStrictEqual(ceil(fromStringUnsafe("-14.5")), fromStringUnsafe("-14"))
+ * assert.deepStrictEqual(BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")), BigDecimal.fromStringUnsafe("-14"))
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const ceil: {
   /**
@@ -2515,18 +2515,18 @@ export const ceil: {
    * **Example** (Rounding decimals up)
    *
    * ```ts
-   * import { ceil, fromStringUnsafe } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   ceil(fromStringUnsafe("145"), -1),
-   *   fromStringUnsafe("150")
+   *   BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1),
+   *   BigDecimal.fromStringUnsafe("150")
    * )
-   * assert.deepStrictEqual(ceil(fromStringUnsafe("-14.5")), fromStringUnsafe("-14"))
+   * assert.deepStrictEqual(BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")), BigDecimal.fromStringUnsafe("-14"))
    * ```
    *
    * @category math
-   * @since 4.0.0
+   * @since 3.16.0
    */
   (scale: number): (self: BigDecimal) => BigDecimal
   /**
@@ -2535,18 +2535,18 @@ export const ceil: {
    * **Example** (Rounding decimals up)
    *
    * ```ts
-   * import { ceil, fromStringUnsafe } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   ceil(fromStringUnsafe("145"), -1),
-   *   fromStringUnsafe("150")
+   *   BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1),
+   *   BigDecimal.fromStringUnsafe("150")
    * )
-   * assert.deepStrictEqual(ceil(fromStringUnsafe("-14.5")), fromStringUnsafe("-14"))
+   * assert.deepStrictEqual(BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")), BigDecimal.fromStringUnsafe("-14"))
    * ```
    *
    * @category math
-   * @since 4.0.0
+   * @since 3.16.0
    */
   (self: BigDecimal, scale?: number): BigDecimal
 } = dual(isBigDecimalArgs, (self: BigDecimal, scale: number = 0): BigDecimal => {
@@ -2598,21 +2598,21 @@ export const digitAt: {
  * **Example** (Rounding decimals down)
  *
  * ```ts
- * import { floor, fromStringUnsafe } from "effect/BigDecimal"
+ * import { BigDecimal } from "effect"
  * import * as assert from "node:assert"
  *
  * assert.deepStrictEqual(
- *   floor(fromStringUnsafe("145"), -1),
- *   fromStringUnsafe("140")
+ *   BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1),
+ *   BigDecimal.fromStringUnsafe("140")
  * )
  * assert.deepStrictEqual(
- *   floor(fromStringUnsafe("-14.5")),
- *   fromStringUnsafe("-15")
+ *   BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")),
+ *   BigDecimal.fromStringUnsafe("-15")
  * )
  * ```
  *
  * @category math
- * @since 4.0.0
+ * @since 3.16.0
  */
 export const floor: {
   /**
@@ -2621,21 +2621,21 @@ export const floor: {
    * **Example** (Rounding decimals down)
    *
    * ```ts
-   * import { floor, fromStringUnsafe } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   floor(fromStringUnsafe("145"), -1),
-   *   fromStringUnsafe("140")
+   *   BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1),
+   *   BigDecimal.fromStringUnsafe("140")
    * )
    * assert.deepStrictEqual(
-   *   floor(fromStringUnsafe("-14.5")),
-   *   fromStringUnsafe("-15")
+   *   BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")),
+   *   BigDecimal.fromStringUnsafe("-15")
    * )
    * ```
    *
    * @category math
-   * @since 4.0.0
+   * @since 3.16.0
    */
   (scale: number): (self: BigDecimal) => BigDecimal
   /**
@@ -2644,21 +2644,21 @@ export const floor: {
    * **Example** (Rounding decimals down)
    *
    * ```ts
-   * import { floor, fromStringUnsafe } from "effect/BigDecimal"
+   * import { BigDecimal } from "effect"
    * import * as assert from "node:assert"
    *
    * assert.deepStrictEqual(
-   *   floor(fromStringUnsafe("145"), -1),
-   *   fromStringUnsafe("140")
+   *   BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1),
+   *   BigDecimal.fromStringUnsafe("140")
    * )
    * assert.deepStrictEqual(
-   *   floor(fromStringUnsafe("-14.5")),
-   *   fromStringUnsafe("-15")
+   *   BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")),
+   *   BigDecimal.fromStringUnsafe("-15")
    * )
    * ```
    *
    * @category math
-   * @since 4.0.0
+   * @since 3.16.0
    */
   (self: BigDecimal, scale?: number): BigDecimal
 } = dual(isBigDecimalArgs, (self: BigDecimal, scale: number = 0): BigDecimal => {