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

package/dist/BigDecimal.d.ts

@@ -88,16 +88,16 @@ export declare const make: (value: bigint, scale: number) => BigDecimal;
  * **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))
  * )
  * ```
  *
@@ -193,12 +193,12 @@ export declare 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")
  * )
  * ```
  *
@@ -212,12 +212,12 @@ export declare 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")
      * )
      * ```
      *
@@ -231,12 +231,12 @@ export declare 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")
      * )
      * ```
      *
@@ -251,17 +251,17 @@ export declare 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 declare const sumAll: (collection: Iterable<BigDecimal>) => BigDecimal;
 /**
@@ -270,12 +270,12 @@ export declare 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")
  * )
  * ```
  *
@@ -289,12 +289,12 @@ export declare 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")
      * )
      * ```
      *
@@ -308,12 +308,12 @@ export declare 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")
      * )
      * ```
      *
@@ -328,12 +328,12 @@ export declare 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")
  * )
  * ```
  *
@@ -347,12 +347,12 @@ export declare const multiplyAll: (collection: Iterable<BigDecimal>) => BigDecim
  * **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")
  * )
  * ```
  *
@@ -366,12 +366,12 @@ export declare 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")
      * )
      * ```
      *
@@ -385,12 +385,12 @@ export declare 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")
      * )
      * ```
      *
@@ -540,14 +540,14 @@ export declare 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 declare const divideUnsafe: {
     /**
@@ -561,14 +561,14 @@ export declare 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;
     /**
@@ -582,14 +582,14 @@ export declare 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;
 };
@@ -620,25 +620,25 @@ export declare const Order: order.Order<BigDecimal>;
  * **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 declare const isLessThan: {
     /**
@@ -647,25 +647,25 @@ export declare 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;
     /**
@@ -674,25 +674,25 @@ export declare 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;
 };
@@ -702,25 +702,25 @@ export declare 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 declare const isLessThanOrEqualTo: {
     /**
@@ -729,25 +729,25 @@ export declare 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;
     /**
@@ -756,25 +756,25 @@ export declare 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;
 };
@@ -784,25 +784,25 @@ export declare 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 declare const isGreaterThan: {
     /**
@@ -811,25 +811,25 @@ export declare 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;
     /**
@@ -838,25 +838,25 @@ export declare 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;
 };
@@ -866,25 +866,25 @@ export declare 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 declare const isGreaterThanOrEqualTo: {
     /**
@@ -893,25 +893,25 @@ export declare 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;
     /**
@@ -920,25 +920,25 @@ export declare 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;
 };
@@ -1139,12 +1139,12 @@ export declare 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")
  * )
  * ```
  *
@@ -1158,12 +1158,12 @@ export declare 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")
      * )
      * ```
      *
@@ -1177,12 +1177,12 @@ export declare 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")
      * )
      * ```
      *
@@ -1197,12 +1197,12 @@ export declare 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")
  * )
  * ```
  *
@@ -1216,12 +1216,12 @@ export declare 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")
      * )
      * ```
      *
@@ -1235,12 +1235,12 @@ export declare 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")
      * )
      * ```
      *
@@ -1255,12 +1255,12 @@ export declare 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
@@ -1273,12 +1273,12 @@ export declare const sign: (n: BigDecimal) => Ordering;
  * **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
@@ -1291,11 +1291,11 @@ export declare const abs: (n: BigDecimal) => BigDecimal;
  * **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
@@ -1425,25 +1425,25 @@ export declare 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 declare const remainderUnsafe: {
     /**
@@ -1454,25 +1454,25 @@ export declare 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;
     /**
@@ -1483,25 +1483,25 @@ export declare 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;
 };
@@ -1616,11 +1616,11 @@ export declare const fromBigInt: (n: bigint) => BigDecimal;
  * **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
@@ -1650,7 +1650,7 @@ export declare const fromNumberUnsafe: (n: number) => BigDecimal;
  * ```
  *
  * @category constructors
- * @since 4.0.0
+ * @since 2.0.0
  */
 export declare const fromNumber: (n: number) => Option.Option<BigDecimal>;
 /**
@@ -1688,16 +1688,16 @@ export declare 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 declare const fromStringUnsafe: (s: string) => BigDecimal;
 /**
@@ -1710,15 +1710,15 @@ export declare 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 declare const format: (n: BigDecimal) => string;
@@ -1728,14 +1728,14 @@ export declare 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 declare const toExponential: (n: BigDecimal) => string;
 /**
@@ -1748,14 +1748,14 @@ export declare 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 declare const toNumberUnsafe: (n: BigDecimal) => number;
 /**
@@ -1764,12 +1764,12 @@ export declare const toNumberUnsafe: (n: BigDecimal) => number;
  * **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
@@ -1782,11 +1782,11 @@ export declare const isInteger: (n: BigDecimal) => boolean;
  * **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
@@ -1799,12 +1799,12 @@ export declare const isZero: (n: BigDecimal) => boolean;
  * **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
@@ -1817,12 +1817,12 @@ export declare const isNegative: (n: BigDecimal) => boolean;
  * **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
@@ -1844,7 +1844,7 @@ export declare const isPositive: (n: BigDecimal) => boolean;
  * `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" | "floor" | "to-zero" | "from-zero" | "half-ceil" | "half-floor" | "half-to-zero" | "half-from-zero" | "half-even" | "half-odd";
 /**
@@ -1853,21 +1853,21 @@ export type RoundingMode = "ceil" | "floor" | "to-zero" | "from-zero" | "half-ce
  * **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 declare const round: {
     /**
@@ -1876,21 +1876,21 @@ export declare 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;
@@ -1902,21 +1902,21 @@ export declare 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;
@@ -1930,14 +1930,14 @@ export declare 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 declare const truncate: {
     /**
@@ -1947,14 +1947,14 @@ export declare 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;
     /**
@@ -1964,14 +1964,14 @@ export declare 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;
 };
@@ -1981,18 +1981,18 @@ export declare 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 declare const ceil: {
     /**
@@ -2001,18 +2001,18 @@ export declare 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;
     /**
@@ -2021,18 +2021,18 @@ export declare 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;
 };
@@ -2042,21 +2042,21 @@ export declare const ceil: {
  * **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 declare const floor: {
     /**
@@ -2065,21 +2065,21 @@ export declare 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;
     /**
@@ -2088,21 +2088,21 @@ export declare 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;
 };