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

package/dist/Number.d.ts

@@ -15,7 +15,7 @@ import * as Reducer from "./Reducer.ts";
  * **Example** (Coercing values to numbers)
  *
  * ```ts
- * import * as N from "effect/Number"
+ * import { Number as N } from "effect"
  *
  * const num = N.Number("42")
  * console.log(num) // 42
@@ -34,11 +34,11 @@ export declare const Number: NumberConstructor;
  * **Example** (Checking for numbers)
  *
  * ```ts
- * import { isNumber } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isNumber(2), true)
- * assert.deepStrictEqual(isNumber("2"), false)
+ * assert.deepStrictEqual(Number.isNumber(2), true)
+ * assert.deepStrictEqual(Number.isNumber("2"), false)
  * ```
  *
  * @category guards
@@ -51,10 +51,10 @@ export declare const isNumber: (input: unknown) => input is number;
  * **Example** (Adding numbers)
  *
  * ```ts
- * import { sum } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sum(2, 3), 5)
+ * assert.deepStrictEqual(Number.sum(2, 3), 5)
  * ```
  *
  * @category math
@@ -67,10 +67,10 @@ export declare const sum: {
      * **Example** (Adding numbers)
      *
      * ```ts
-     * import { sum } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(sum(2, 3), 5)
+     * assert.deepStrictEqual(Number.sum(2, 3), 5)
      * ```
      *
      * @category math
@@ -83,10 +83,10 @@ export declare const sum: {
      * **Example** (Adding numbers)
      *
      * ```ts
-     * import { sum } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(sum(2, 3), 5)
+     * assert.deepStrictEqual(Number.sum(2, 3), 5)
      * ```
      *
      * @category math
@@ -100,10 +100,10 @@ export declare const sum: {
  * **Example** (Multiplying numbers)
  *
  * ```ts
- * import { multiply } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiply(2, 3), 6)
+ * assert.deepStrictEqual(Number.multiply(2, 3), 6)
  * ```
  *
  * @category math
@@ -116,10 +116,10 @@ export declare const multiply: {
      * **Example** (Multiplying numbers)
      *
      * ```ts
-     * import { multiply } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(multiply(2, 3), 6)
+     * assert.deepStrictEqual(Number.multiply(2, 3), 6)
      * ```
      *
      * @category math
@@ -132,10 +132,10 @@ export declare const multiply: {
      * **Example** (Multiplying numbers)
      *
      * ```ts
-     * import { multiply } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(multiply(2, 3), 6)
+     * assert.deepStrictEqual(Number.multiply(2, 3), 6)
      * ```
      *
      * @category math
@@ -149,10 +149,10 @@ export declare const multiply: {
  * **Example** (Subtracting numbers)
  *
  * ```ts
- * import { subtract } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(subtract(2, 3), -1)
+ * assert.deepStrictEqual(Number.subtract(2, 3), -1)
  * ```
  *
  * @category math
@@ -165,10 +165,10 @@ export declare const subtract: {
      * **Example** (Subtracting numbers)
      *
      * ```ts
-     * import { subtract } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(subtract(2, 3), -1)
+     * assert.deepStrictEqual(Number.subtract(2, 3), -1)
      * ```
      *
      * @category math
@@ -181,10 +181,10 @@ export declare const subtract: {
      * **Example** (Subtracting numbers)
      *
      * ```ts
-     * import { subtract } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(subtract(2, 3), -1)
+     * assert.deepStrictEqual(Number.subtract(2, 3), -1)
      * ```
      *
      * @category math
@@ -263,7 +263,7 @@ export declare const divide: {
  * ```
  *
  * @category math
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const divideUnsafe: {
     /**
@@ -282,7 +282,7 @@ export declare const divideUnsafe: {
      * ```
      *
      * @category math
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => number;
     /**
@@ -301,7 +301,7 @@ export declare const divideUnsafe: {
      * ```
      *
      * @category math
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): number;
 };
@@ -311,10 +311,10 @@ export declare const divideUnsafe: {
  * **Example** (Incrementing a number)
  *
  * ```ts
- * import { increment } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(increment(2), 3)
+ * assert.deepStrictEqual(Number.increment(2), 3)
  * ```
  *
  * @category math
@@ -327,10 +327,10 @@ export declare const increment: (n: number) => number;
  * **Example** (Decrementing a number)
  *
  * ```ts
- * import { decrement } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(decrement(3), 2)
+ * assert.deepStrictEqual(Number.decrement(3), 2)
  * ```
  *
  * @category math
@@ -343,7 +343,7 @@ export declare const decrement: (n: number) => number;
  * **Example** (Comparing numbers)
  *
  * ```ts
- * import * as Number from "effect/Number"
+ * import { Number } from "effect"
  *
  * console.log(Number.Order(1, 2)) // -1
  * console.log(Number.Order(2, 1)) // 1
@@ -370,7 +370,7 @@ export declare const Order: order.Order<number>;
  * ```
  *
  * @category instances
- * @since 4.0.0
+ * @since 2.0.0
  */
 export declare const Equivalence: Equ.Equivalence<number>;
 /**
@@ -379,16 +379,16 @@ export declare const Equivalence: Equ.Equivalence<number>;
  * **Example** (Checking less-than comparisons)
  *
  * ```ts
- * import { isLessThan } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThan(2, 3), true)
- * assert.deepStrictEqual(isLessThan(3, 3), false)
- * assert.deepStrictEqual(isLessThan(4, 3), false)
+ * assert.deepStrictEqual(Number.isLessThan(2, 3), true)
+ * assert.deepStrictEqual(Number.isLessThan(3, 3), false)
+ * assert.deepStrictEqual(Number.isLessThan(4, 3), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isLessThan: {
     /**
@@ -397,16 +397,16 @@ export declare const isLessThan: {
      * **Example** (Checking less-than comparisons)
      *
      * ```ts
-     * import { isLessThan } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThan(2, 3), true)
-     * assert.deepStrictEqual(isLessThan(3, 3), false)
-     * assert.deepStrictEqual(isLessThan(4, 3), false)
+     * assert.deepStrictEqual(Number.isLessThan(2, 3), true)
+     * assert.deepStrictEqual(Number.isLessThan(3, 3), false)
+     * assert.deepStrictEqual(Number.isLessThan(4, 3), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => boolean;
     /**
@@ -415,16 +415,16 @@ export declare const isLessThan: {
      * **Example** (Checking less-than comparisons)
      *
      * ```ts
-     * import { isLessThan } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThan(2, 3), true)
-     * assert.deepStrictEqual(isLessThan(3, 3), false)
-     * assert.deepStrictEqual(isLessThan(4, 3), false)
+     * assert.deepStrictEqual(Number.isLessThan(2, 3), true)
+     * assert.deepStrictEqual(Number.isLessThan(3, 3), false)
+     * assert.deepStrictEqual(Number.isLessThan(4, 3), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): boolean;
 };
@@ -434,16 +434,16 @@ export declare const isLessThan: {
  * **Example** (Checking less-than-or-equal comparisons)
  *
  * ```ts
- * import { isLessThanOrEqualTo } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isLessThanOrEqualTo(2, 3), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(3, 3), true)
- * assert.deepStrictEqual(isLessThanOrEqualTo(4, 3), false)
+ * assert.deepStrictEqual(Number.isLessThanOrEqualTo(2, 3), true)
+ * assert.deepStrictEqual(Number.isLessThanOrEqualTo(3, 3), true)
+ * assert.deepStrictEqual(Number.isLessThanOrEqualTo(4, 3), false)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isLessThanOrEqualTo: {
     /**
@@ -452,16 +452,16 @@ export declare const isLessThanOrEqualTo: {
      * **Example** (Checking less-than-or-equal comparisons)
      *
      * ```ts
-     * import { isLessThanOrEqualTo } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThanOrEqualTo(2, 3), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(3, 3), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(4, 3), false)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(2, 3), true)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(3, 3), true)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(4, 3), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => boolean;
     /**
@@ -470,16 +470,16 @@ export declare const isLessThanOrEqualTo: {
      * **Example** (Checking less-than-or-equal comparisons)
      *
      * ```ts
-     * import { isLessThanOrEqualTo } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isLessThanOrEqualTo(2, 3), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(3, 3), true)
-     * assert.deepStrictEqual(isLessThanOrEqualTo(4, 3), false)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(2, 3), true)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(3, 3), true)
+     * assert.deepStrictEqual(Number.isLessThanOrEqualTo(4, 3), false)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): boolean;
 };
@@ -489,16 +489,16 @@ export declare const isLessThanOrEqualTo: {
  * **Example** (Checking greater-than comparisons)
  *
  * ```ts
- * import { isGreaterThan } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThan(2, 3), false)
- * assert.deepStrictEqual(isGreaterThan(3, 3), false)
- * assert.deepStrictEqual(isGreaterThan(4, 3), true)
+ * assert.deepStrictEqual(Number.isGreaterThan(2, 3), false)
+ * assert.deepStrictEqual(Number.isGreaterThan(3, 3), false)
+ * assert.deepStrictEqual(Number.isGreaterThan(4, 3), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isGreaterThan: {
     /**
@@ -507,16 +507,16 @@ export declare const isGreaterThan: {
      * **Example** (Checking greater-than comparisons)
      *
      * ```ts
-     * import { isGreaterThan } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThan(2, 3), false)
-     * assert.deepStrictEqual(isGreaterThan(3, 3), false)
-     * assert.deepStrictEqual(isGreaterThan(4, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThan(2, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThan(3, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThan(4, 3), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => boolean;
     /**
@@ -525,16 +525,16 @@ export declare const isGreaterThan: {
      * **Example** (Checking greater-than comparisons)
      *
      * ```ts
-     * import { isGreaterThan } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThan(2, 3), false)
-     * assert.deepStrictEqual(isGreaterThan(3, 3), false)
-     * assert.deepStrictEqual(isGreaterThan(4, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThan(2, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThan(3, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThan(4, 3), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): boolean;
 };
@@ -544,16 +544,16 @@ export declare const isGreaterThan: {
  * **Example** (Checking greater-than-or-equal comparisons)
  *
  * ```ts
- * import { isGreaterThanOrEqualTo } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(2, 3), false)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(3, 3), true)
- * assert.deepStrictEqual(isGreaterThanOrEqualTo(4, 3), true)
+ * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(2, 3), false)
+ * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(3, 3), true)
+ * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(4, 3), true)
  * ```
  *
  * @category predicates
- * @since 2.0.0
+ * @since 4.0.0
  */
 export declare const isGreaterThanOrEqualTo: {
     /**
@@ -562,16 +562,16 @@ export declare const isGreaterThanOrEqualTo: {
      * **Example** (Checking greater-than-or-equal comparisons)
      *
      * ```ts
-     * import { isGreaterThanOrEqualTo } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(2, 3), false)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(3, 3), true)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(4, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(2, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(3, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(4, 3), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (that: number): (self: number) => boolean;
     /**
@@ -580,16 +580,16 @@ export declare const isGreaterThanOrEqualTo: {
      * **Example** (Checking greater-than-or-equal comparisons)
      *
      * ```ts
-     * import { isGreaterThanOrEqualTo } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(2, 3), false)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(3, 3), true)
-     * assert.deepStrictEqual(isGreaterThanOrEqualTo(4, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(2, 3), false)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(3, 3), true)
+     * assert.deepStrictEqual(Number.isGreaterThanOrEqualTo(4, 3), true)
      * ```
      *
      * @category predicates
-     * @since 2.0.0
+     * @since 4.0.0
      */
     (self: number, that: number): boolean;
 };
@@ -599,7 +599,7 @@ export declare const isGreaterThanOrEqualTo: {
  * **Example** (Checking inclusive ranges)
  *
  * ```ts
- * import * as Number from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
  * const between = Number.between({ minimum: 0, maximum: 5 })
@@ -619,7 +619,7 @@ export declare const between: {
      * **Example** (Checking inclusive ranges)
      *
      * ```ts
-     * import * as Number from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
      * const between = Number.between({ minimum: 0, maximum: 5 })
@@ -642,7 +642,7 @@ export declare const between: {
      * **Example** (Checking inclusive ranges)
      *
      * ```ts
-     * import * as Number from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
      * const between = Number.between({ minimum: 0, maximum: 5 })
@@ -670,7 +670,7 @@ export declare const between: {
  * **Example** (Clamping to a range)
  *
  * ```ts
- * import * as Number from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
  * const clamp = Number.clamp({ minimum: 1, maximum: 5 })
@@ -694,7 +694,7 @@ export declare const clamp: {
      * **Example** (Clamping to a range)
      *
      * ```ts
-     * import * as Number from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
      * const clamp = Number.clamp({ minimum: 1, maximum: 5 })
@@ -721,7 +721,7 @@ export declare const clamp: {
      * **Example** (Clamping to a range)
      *
      * ```ts
-     * import * as Number from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
      * const clamp = Number.clamp({ minimum: 1, maximum: 5 })
@@ -745,10 +745,10 @@ export declare const clamp: {
  * **Example** (Finding the minimum)
  *
  * ```ts
- * import { min } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(min(2, 3), 2)
+ * assert.deepStrictEqual(Number.min(2, 3), 2)
  * ```
  *
  * @category math
@@ -761,10 +761,10 @@ export declare const min: {
      * **Example** (Finding the minimum)
      *
      * ```ts
-     * import { min } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(min(2, 3), 2)
+     * assert.deepStrictEqual(Number.min(2, 3), 2)
      * ```
      *
      * @category math
@@ -777,10 +777,10 @@ export declare const min: {
      * **Example** (Finding the minimum)
      *
      * ```ts
-     * import { min } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(min(2, 3), 2)
+     * assert.deepStrictEqual(Number.min(2, 3), 2)
      * ```
      *
      * @category math
@@ -794,10 +794,10 @@ export declare const min: {
  * **Example** (Finding the maximum)
  *
  * ```ts
- * import { max } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(max(2, 3), 3)
+ * assert.deepStrictEqual(Number.max(2, 3), 3)
  * ```
  *
  * @category math
@@ -810,10 +810,10 @@ export declare const max: {
      * **Example** (Finding the maximum)
      *
      * ```ts
-     * import { max } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(max(2, 3), 3)
+     * assert.deepStrictEqual(Number.max(2, 3), 3)
      * ```
      *
      * @category math
@@ -826,10 +826,10 @@ export declare const max: {
      * **Example** (Finding the maximum)
      *
      * ```ts
-     * import { max } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(max(2, 3), 3)
+     * assert.deepStrictEqual(Number.max(2, 3), 3)
      * ```
      *
      * @category math
@@ -843,12 +843,12 @@ export declare const max: {
  * **Example** (Determining the sign)
  *
  * ```ts
- * import { sign } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sign(-5), -1)
- * assert.deepStrictEqual(sign(0), 0)
- * assert.deepStrictEqual(sign(5), 1)
+ * assert.deepStrictEqual(Number.sign(-5), -1)
+ * assert.deepStrictEqual(Number.sign(0), 0)
+ * assert.deepStrictEqual(Number.sign(5), 1)
  * ```
  *
  * @category math
@@ -861,10 +861,10 @@ export declare const sign: (n: number) => Ordering;
  * **Example** (Summing an iterable)
  *
  * ```ts
- * import { sumAll } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(sumAll([2, 3, 4]), 9)
+ * assert.deepStrictEqual(Number.sumAll([2, 3, 4]), 9)
  * ```
  *
  * @category math
@@ -877,10 +877,10 @@ export declare const sumAll: (collection: Iterable<number>) => number;
  * **Example** (Multiplying an iterable)
  *
  * ```ts
- * import { multiplyAll } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(multiplyAll([2, 3, 4]), 24)
+ * assert.deepStrictEqual(Number.multiplyAll([2, 3, 4]), 24)
  * ```
  *
  * @category math
@@ -895,12 +895,12 @@ export declare const multiplyAll: (collection: Iterable<number>) => number;
  * **Example** (Calculating remainders)
  *
  * ```ts
- * import { remainder } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(remainder(2, 2), 0)
- * assert.deepStrictEqual(remainder(3, 2), 1)
- * assert.deepStrictEqual(remainder(-4, 2), -0)
+ * assert.deepStrictEqual(Number.remainder(2, 2), 0)
+ * assert.deepStrictEqual(Number.remainder(3, 2), 1)
+ * assert.deepStrictEqual(Number.remainder(-4, 2), -0)
  * ```
  *
  * @category math
@@ -915,12 +915,12 @@ export declare const remainder: {
      * **Example** (Calculating remainders)
      *
      * ```ts
-     * import { remainder } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(remainder(2, 2), 0)
-     * assert.deepStrictEqual(remainder(3, 2), 1)
-     * assert.deepStrictEqual(remainder(-4, 2), -0)
+     * assert.deepStrictEqual(Number.remainder(2, 2), 0)
+     * assert.deepStrictEqual(Number.remainder(3, 2), 1)
+     * assert.deepStrictEqual(Number.remainder(-4, 2), -0)
      * ```
      *
      * @category math
@@ -935,12 +935,12 @@ export declare const remainder: {
      * **Example** (Calculating remainders)
      *
      * ```ts
-     * import { remainder } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(remainder(2, 2), 0)
-     * assert.deepStrictEqual(remainder(3, 2), 1)
-     * assert.deepStrictEqual(remainder(-4, 2), -0)
+     * assert.deepStrictEqual(Number.remainder(2, 2), 0)
+     * assert.deepStrictEqual(Number.remainder(3, 2), 1)
+     * assert.deepStrictEqual(Number.remainder(-4, 2), -0)
      * ```
      *
      * @category math
@@ -954,11 +954,11 @@ export declare const remainder: {
  * **Example** (Finding the next power of two)
  *
  * ```ts
- * import { nextPow2 } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(nextPow2(5), 8)
- * assert.deepStrictEqual(nextPow2(17), 32)
+ * assert.deepStrictEqual(Number.nextPow2(5), 8)
+ * assert.deepStrictEqual(Number.nextPow2(17), 32)
  * ```
  *
  * @category math
@@ -992,11 +992,11 @@ export declare const parse: (s: string) => Option.Option<number>;
  * **Example** (Rounding with precision)
  *
  * ```ts
- * import { round } from "effect/Number"
+ * import { Number } from "effect"
  * import * as assert from "node:assert"
  *
- * assert.deepStrictEqual(round(1.1234, 2), 1.12)
- * assert.deepStrictEqual(round(1.567, 2), 1.57)
+ * assert.deepStrictEqual(Number.round(1.1234, 2), 1.12)
+ * assert.deepStrictEqual(Number.round(1.567, 2), 1.57)
  * ```
  *
  * @category math
@@ -1009,11 +1009,11 @@ export declare const round: {
      * **Example** (Rounding with precision)
      *
      * ```ts
-     * import { round } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(round(1.1234, 2), 1.12)
-     * assert.deepStrictEqual(round(1.567, 2), 1.57)
+     * assert.deepStrictEqual(Number.round(1.1234, 2), 1.12)
+     * assert.deepStrictEqual(Number.round(1.567, 2), 1.57)
      * ```
      *
      * @category math
@@ -1026,11 +1026,11 @@ export declare const round: {
      * **Example** (Rounding with precision)
      *
      * ```ts
-     * import { round } from "effect/Number"
+     * import { Number } from "effect"
      * import * as assert from "node:assert"
      *
-     * assert.deepStrictEqual(round(1.1234, 2), 1.12)
-     * assert.deepStrictEqual(round(1.567, 2), 1.57)
+     * assert.deepStrictEqual(Number.round(1.1234, 2), 1.12)
+     * assert.deepStrictEqual(Number.round(1.567, 2), 1.57)
      * ```
      *
      * @category math
@@ -1041,24 +1041,28 @@ export declare const round: {
 /**
  * A `Reducer` for combining `number`s using addition.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerSum: Reducer.Reducer<number>;
 /**
  * A `Reducer` for combining `number`s using multiplication.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerMultiply: Reducer.Reducer<number>;
 /**
  * A `Reducer` for reducing `number`s by keeping the maximum value.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerMax: Reducer.Reducer<number>;
 /**
  * A `Reducer` for reducing `number`s by keeping the minimum value.
  *
+ * @category math
  * @since 4.0.0
  */
 export declare const ReducerMin: Reducer.Reducer<number>;