/**
 * Decimal numbers and arithmetic for cases where JavaScript `number` rounding
 * is not precise enough. A `BigDecimal` stores digits as a `bigint` plus a
 * decimal scale, which lets the module parse, compare, add, subtract, multiply,
 * divide, round, and format decimal values such as money, quantities, and
 * measurements.
 *
 * @stability stable
 * @since 2.0.0
 */
import * as Equal from "./Equal.ts";
import * as Equ from "./Equivalence.ts";
import { type Inspectable } from "./Inspectable.ts";
import * as Option from "./Option.ts";
import * as order from "./Order.ts";
import type { Ordering } from "./Ordering.ts";
import { type Pipeable } from "./Pipeable.ts";
declare const TypeId = "~effect/BigDecimal";
/**
 * Represents an arbitrary precision decimal number.
 *
 * **When to use**
 *
 * Use when decimal arithmetic needs to avoid JavaScript floating point
 * representation errors.
 *
 * **Example** (Inspecting BigDecimal storage)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const d = BigDecimal.fromStringUnsafe("123.45")
 *
 * d.value // => 12345n
 * d.scale // => 2
 * ```
 *
 * @stability stable
 * @category models
 * @since 2.0.0
 */
export interface BigDecimal extends Equal.Equal, Pipeable, Inspectable {
    readonly [TypeId]: typeof TypeId;
    readonly value: bigint;
    readonly scale: number;
}
/**
 * Checks whether a given value is a `BigDecimal`.
 *
 * **When to use**
 *
 * Use to validate unknown input and narrow it to `BigDecimal`.
 *
 * **Example** (Checking BigDecimal values)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const decimal = BigDecimal.fromNumber(123.45)
 * BigDecimal.isBigDecimal(decimal) // => false
 * BigDecimal.isBigDecimal(BigDecimal.fromStringUnsafe("123.45")) // => true
 * BigDecimal.isBigDecimal(123.45) // => false
 * BigDecimal.isBigDecimal("123.45") // => false
 * ```
 *
 * @stability stable
 * @category guards
 * @since 2.0.0
 */
export declare const isBigDecimal: (u: unknown) => u is BigDecimal;
/**
 * Creates a `BigDecimal` from a `bigint` value and a safe integer scale.
 *
 * **When to use**
 *
 * Use to construct a decimal directly from its unscaled integer value and
 * decimal scale.
 *
 * **Gotchas**
 *
 * Throws a `RangeError` if `scale` is not a safe integer.
 *
 * **Example** (Creating decimals from bigint and scale)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * // Create 123.45 (12345 with scale 2)
 * const decimal = BigDecimal.make(12345n, 2)
 * decimal // => BigDecimal.fromStringUnsafe("123.45")
 *
 * // Create 42 (42 with scale 0)
 * const integer = BigDecimal.make(42n, 0)
 * integer // => BigDecimal.fromBigInt(42n)
 * ```
 *
 * @see {@link fromBigInt} for constructing an integer decimal from a `bigint`
 *
 * @stability stable
 * @category constructors
 * @since 2.0.0
 */
export declare const make: (value: bigint, scale: number) => BigDecimal;
/**
 * Normalizes a given `BigDecimal` by removing trailing zeros.
 *
 * **When to use**
 *
 * Use to canonicalize decimals that have equivalent values but different
 * internal scales.
 *
 * **Example** (Normalizing trailing zeros)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const decimal = BigDecimal.normalize(BigDecimal.fromStringUnsafe("123.00000"))
 * const decimalStorage = [decimal.value, decimal.scale] // => [123n, 0]
 *
 * const largeDecimal = BigDecimal.normalize(BigDecimal.fromStringUnsafe("12300000"))
 * const largeDecimalStorage = [largeDecimal.value, largeDecimal.scale] // => [123n, -5]
 * ```
 *
 * @see {@link format} for rendering normalized decimals as strings
 *
 * @stability stable
 * @category scaling
 * @since 2.0.0
 */
export declare const normalize: (self: BigDecimal) => BigDecimal;
/**
 * Changes a `BigDecimal` to the specified scale.
 *
 * **When to use**
 *
 * Use to change how many decimal places are represented by a `BigDecimal`.
 *
 * **Details**
 *
 * Increasing the scale appends decimal zeros. Decreasing the scale discards
 * digits beyond the target scale by `bigint` division, which truncates toward
 * zero.
 *
 * **Example** (Scaling decimal precision)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const decimal = BigDecimal.fromNumberUnsafe(123.45)
 *
 * // Increase scale (add more precision)
 * const scaled = BigDecimal.scale(decimal, 4)
 * const scaledStorage = [scaled.value, scaled.scale] // => [1234500n, 4]
 *
 * // Decrease scale (reduce precision, truncating toward zero)
 * const reduced = BigDecimal.scale(decimal, 1)
 * reduced // => BigDecimal.fromStringUnsafe("123.4")
 * ```
 *
 * @see {@link round} for changing scale with configurable rounding
 *
 * @stability stable
 * @category scaling
 * @since 2.0.0
 */
export declare const scale: {
    /**
     * Changes a `BigDecimal` to the specified scale.
     *
     * **When to use**
     *
     * Use to change how many decimal places are represented by a `BigDecimal`.
     *
     * **Details**
     *
     * Increasing the scale appends decimal zeros. Decreasing the scale discards
     * digits beyond the target scale by `bigint` division, which truncates toward
     * zero.
     *
     * **Example** (Scaling decimal precision)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const decimal = BigDecimal.fromNumberUnsafe(123.45)
     *
     * // Increase scale (add more precision)
     * const scaled = BigDecimal.scale(decimal, 4)
     * const scaledStorage = [scaled.value, scaled.scale] // => [1234500n, 4]
     *
     * // Decrease scale (reduce precision, truncating toward zero)
     * const reduced = BigDecimal.scale(decimal, 1)
     * reduced // => BigDecimal.fromStringUnsafe("123.4")
     * ```
     *
     * @see {@link round} for changing scale with configurable rounding
     *
     * @stability stable
     * @category scaling
     * @since 2.0.0
     */
    (scale: number): (self: BigDecimal) => BigDecimal;
    /**
     * Changes a `BigDecimal` to the specified scale.
     *
     * **When to use**
     *
     * Use to change how many decimal places are represented by a `BigDecimal`.
     *
     * **Details**
     *
     * Increasing the scale appends decimal zeros. Decreasing the scale discards
     * digits beyond the target scale by `bigint` division, which truncates toward
     * zero.
     *
     * **Example** (Scaling decimal precision)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const decimal = BigDecimal.fromNumberUnsafe(123.45)
     *
     * // Increase scale (add more precision)
     * const scaled = BigDecimal.scale(decimal, 4)
     * const scaledStorage = [scaled.value, scaled.scale] // => [1234500n, 4]
     *
     * // Decrease scale (reduce precision, truncating toward zero)
     * const reduced = BigDecimal.scale(decimal, 1)
     * reduced // => BigDecimal.fromStringUnsafe("123.4")
     * ```
     *
     * @see {@link round} for changing scale with configurable rounding
     *
     * @stability stable
     * @category scaling
     * @since 2.0.0
     */
    (self: BigDecimal, scale: number): BigDecimal;
};
/**
 * Provides an addition operation on `BigDecimal`s.
 *
 * **When to use**
 *
 * Use when you need a decimal addition function for piping or higher-order APIs
 * while preserving decimal precision.
 *
 * **Example** (Adding decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const result = BigDecimal.sum(
 *   BigDecimal.fromStringUnsafe("2"),
 *   BigDecimal.fromStringUnsafe("3")
 * ) // => BigDecimal.fromBigInt(5n)
 * ```
 *
 * @see {@link sumAll} for summing an iterable of `BigDecimal` values
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const sum: {
    /**
     * Provides an addition operation on `BigDecimal`s.
     *
     * **When to use**
     *
     * Use when you need a decimal addition function for piping or higher-order APIs
     * while preserving decimal precision.
     *
     * **Example** (Adding decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.sum(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(5n)
     * ```
     *
     * @see {@link sumAll} for summing an iterable of `BigDecimal` values
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
    /**
     * Provides an addition operation on `BigDecimal`s.
     *
     * **When to use**
     *
     * Use when you need a decimal addition function for piping or higher-order APIs
     * while preserving decimal precision.
     *
     * **Example** (Adding decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.sum(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(5n)
     * ```
     *
     * @see {@link sumAll} for summing an iterable of `BigDecimal` values
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (self: BigDecimal, that: BigDecimal): BigDecimal;
};
/**
 * Takes an `Iterable` of `BigDecimal`s and returns their sum as a single `BigDecimal`.
 *
 * **When to use**
 *
 * Use when you need to aggregate decimal quantities with decimal precision
 * instead of converting through JavaScript numbers.
 *
 * **Example** (Adding multiple decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const result = BigDecimal.sumAll([
 *   BigDecimal.fromStringUnsafe("2"),
 *   BigDecimal.fromStringUnsafe("3"),
 *   BigDecimal.fromStringUnsafe("4")
 * ]) // => BigDecimal.fromBigInt(9n)
 * ```
 *
 * @see {@link sum} for adding two `BigDecimal` values
 *
 * @stability stable
 * @category math
 * @since 3.16.0
 */
export declare const sumAll: (collection: Iterable<BigDecimal>) => BigDecimal;
/**
 * Provides a multiplication operation on `BigDecimal`s.
 *
 * **When to use**
 *
 * Use to multiply two `BigDecimal` values.
 *
 * **Example** (Multiplying decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const result = BigDecimal.multiply(
 *   BigDecimal.fromStringUnsafe("2"),
 *   BigDecimal.fromStringUnsafe("3")
 * ) // => BigDecimal.fromBigInt(6n)
 * ```
 *
 * @see {@link multiplyAll} for multiplying an iterable of `BigDecimal` values
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const multiply: {
    /**
     * Provides a multiplication operation on `BigDecimal`s.
     *
     * **When to use**
     *
     * Use to multiply two `BigDecimal` values.
     *
     * **Example** (Multiplying decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.multiply(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(6n)
     * ```
     *
     * @see {@link multiplyAll} for multiplying an iterable of `BigDecimal` values
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
    /**
     * Provides a multiplication operation on `BigDecimal`s.
     *
     * **When to use**
     *
     * Use to multiply two `BigDecimal` values.
     *
     * **Example** (Multiplying decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.multiply(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(6n)
     * ```
     *
     * @see {@link multiplyAll} for multiplying an iterable of `BigDecimal` values
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (self: BigDecimal, that: BigDecimal): BigDecimal;
};
/**
 * Takes an `Iterable` of `BigDecimal`s and returns their multiplication as a single `BigDecimal`.
 *
 * **When to use**
 *
 * Use to multiply all `BigDecimal` values in an iterable.
 *
 * **Example** (Multiplying multiple decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const result = BigDecimal.multiplyAll([
 *   BigDecimal.fromStringUnsafe("2"),
 *   BigDecimal.fromStringUnsafe("3"),
 *   BigDecimal.fromStringUnsafe("4")
 * ]) // => BigDecimal.fromBigInt(24n)
 * ```
 *
 * @see {@link multiply} for multiplying two `BigDecimal` values
 *
 * @stability stable
 * @category math
 * @since 4.0.0
 */
export declare const multiplyAll: (collection: Iterable<BigDecimal>) => BigDecimal;
/**
 * Provides a subtraction operation on `BigDecimal`s.
 *
 * **When to use**
 *
 * Use to subtract one `BigDecimal` value from another.
 *
 * **Example** (Subtracting decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const result = BigDecimal.subtract(
 *   BigDecimal.fromStringUnsafe("2"),
 *   BigDecimal.fromStringUnsafe("3")
 * ) // => BigDecimal.fromBigInt(-1n)
 * ```
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const subtract: {
    /**
     * Provides a subtraction operation on `BigDecimal`s.
     *
     * **When to use**
     *
     * Use to subtract one `BigDecimal` value from another.
     *
     * **Example** (Subtracting decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.subtract(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(-1n)
     * ```
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
    /**
     * Provides a subtraction operation on `BigDecimal`s.
     *
     * **When to use**
     *
     * Use to subtract one `BigDecimal` value from another.
     *
     * **Example** (Subtracting decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.subtract(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(-1n)
     * ```
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (self: BigDecimal, that: BigDecimal): BigDecimal;
};
/**
 * Divides `BigDecimal`s safely.
 *
 * **When to use**
 *
 * Use to divide `BigDecimal` values while representing division by zero as
 * `Option.none`.
 *
 * **Details**
 *
 * If the dividend is not a multiple of the divisor, the result will be a `BigDecimal` value
 * with up to the default division precision. If the divisor is `0`, the result
 * will be `Option.none()`.
 *
 * **Example** (Dividing decimals safely)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal, Option } from "effect"
 *
 * const six = BigDecimal.fromBigInt(6n)
 *
 * BigDecimal.divide(six, BigDecimal.fromBigInt(3n)) // => Option.some(BigDecimal.fromBigInt(2n))
 * BigDecimal.divide(six, BigDecimal.fromBigInt(4n)) // => Option.some(BigDecimal.fromStringUnsafe("1.5"))
 * BigDecimal.divide(six, BigDecimal.fromBigInt(0n)) // => Option.none()
 * ```
 *
 * @see {@link divideUnsafe} for division that throws when the divisor is zero
 * @see {@link remainder} for the decimal remainder operation
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const divide: {
    /**
     * Divides `BigDecimal`s safely.
     *
     * **When to use**
     *
     * Use to divide `BigDecimal` values while representing division by zero as
     * `Option.none`.
     *
     * **Details**
     *
     * If the dividend is not a multiple of the divisor, the result will be a `BigDecimal` value
     * with up to the default division precision. If the divisor is `0`, the result
     * will be `Option.none()`.
     *
     * **Example** (Dividing decimals safely)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal, Option } from "effect"
     *
     * const six = BigDecimal.fromBigInt(6n)
     *
     * BigDecimal.divide(six, BigDecimal.fromBigInt(3n)) // => Option.some(BigDecimal.fromBigInt(2n))
     * BigDecimal.divide(six, BigDecimal.fromBigInt(4n)) // => Option.some(BigDecimal.fromStringUnsafe("1.5"))
     * BigDecimal.divide(six, BigDecimal.fromBigInt(0n)) // => Option.none()
     * ```
     *
     * @see {@link divideUnsafe} for division that throws when the divisor is zero
     * @see {@link remainder} for the decimal remainder operation
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => Option.Option<BigDecimal>;
    /**
     * Divides `BigDecimal`s safely.
     *
     * **When to use**
     *
     * Use to divide `BigDecimal` values while representing division by zero as
     * `Option.none`.
     *
     * **Details**
     *
     * If the dividend is not a multiple of the divisor, the result will be a `BigDecimal` value
     * with up to the default division precision. If the divisor is `0`, the result
     * will be `Option.none()`.
     *
     * **Example** (Dividing decimals safely)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal, Option } from "effect"
     *
     * const six = BigDecimal.fromBigInt(6n)
     *
     * BigDecimal.divide(six, BigDecimal.fromBigInt(3n)) // => Option.some(BigDecimal.fromBigInt(2n))
     * BigDecimal.divide(six, BigDecimal.fromBigInt(4n)) // => Option.some(BigDecimal.fromStringUnsafe("1.5"))
     * BigDecimal.divide(six, BigDecimal.fromBigInt(0n)) // => Option.none()
     * ```
     *
     * @see {@link divideUnsafe} for division that throws when the divisor is zero
     * @see {@link remainder} for the decimal remainder operation
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (self: BigDecimal, that: BigDecimal): Option.Option<BigDecimal>;
};
/**
 * Provides an unsafe division operation on `BigDecimal`s.
 *
 * **When to use**
 *
 * Use when you need to divide `BigDecimal` values where the divisor is known
 * to be non-zero, so division by zero should be a thrown exception.
 *
 * **Details**
 *
 * If the dividend is not a multiple of the divisor, the result will be a `BigDecimal` value
 * with up to the default division precision.
 *
 * **Gotchas**
 *
 * Throws a `RangeError` if the divisor is `0`.
 *
 * **Example** (Dividing decimals unsafely)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(2n)
 * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("4")) // => BigDecimal.fromStringUnsafe("1.5")
 * ```
 *
 * @see {@link divide} for division that returns `Option.none` when the divisor is zero
 *
 * @stability stable
 * @category math
 * @since 4.0.0
 */
export declare const divideUnsafe: {
    /**
     * Provides an unsafe division operation on `BigDecimal`s.
     *
     * **When to use**
     *
     * Use when you need to divide `BigDecimal` values where the divisor is known
     * to be non-zero, so division by zero should be a thrown exception.
     *
     * **Details**
     *
     * If the dividend is not a multiple of the divisor, the result will be a `BigDecimal` value
     * with up to the default division precision.
     *
     * **Gotchas**
     *
     * Throws a `RangeError` if the divisor is `0`.
     *
     * **Example** (Dividing decimals unsafely)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(2n)
     * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("4")) // => BigDecimal.fromStringUnsafe("1.5")
     * ```
     *
     * @see {@link divide} for division that returns `Option.none` when the divisor is zero
     *
     * @stability stable
     * @category math
     * @since 4.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
    /**
     * Provides an unsafe division operation on `BigDecimal`s.
     *
     * **When to use**
     *
     * Use when you need to divide `BigDecimal` values where the divisor is known
     * to be non-zero, so division by zero should be a thrown exception.
     *
     * **Details**
     *
     * If the dividend is not a multiple of the divisor, the result will be a `BigDecimal` value
     * with up to the default division precision.
     *
     * **Gotchas**
     *
     * Throws a `RangeError` if the divisor is `0`.
     *
     * **Example** (Dividing decimals unsafely)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(2n)
     * BigDecimal.divideUnsafe(BigDecimal.fromStringUnsafe("6"), BigDecimal.fromStringUnsafe("4")) // => BigDecimal.fromStringUnsafe("1.5")
     * ```
     *
     * @see {@link divide} for division that returns `Option.none` when the divisor is zero
     *
     * @stability stable
     * @category math
     * @since 4.0.0
     */
    (self: BigDecimal, that: BigDecimal): BigDecimal;
};
/**
 * Provides an `Order` instance for `BigDecimal` that allows comparing and sorting BigDecimal values.
 *
 * **When to use**
 *
 * Use when you need to sort or compare decimal values through APIs that accept
 * an ordering instance.
 *
 * **Example** (Comparing decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const a = BigDecimal.fromNumberUnsafe(1.5)
 * const b = BigDecimal.fromNumberUnsafe(2.3)
 * const c = BigDecimal.fromNumberUnsafe(1.5)
 *
 * BigDecimal.Order(a, b) // => -1
 * BigDecimal.Order(b, a) // => 1
 * BigDecimal.Order(a, c) // => 0
 * ```
 *
 * @stability stable
 * @category instances
 * @since 2.0.0
 */
export declare const Order: order.Order<BigDecimal>;
/**
 * Returns `true` if the first argument is less than the second, otherwise `false`.
 *
 * **When to use**
 *
 * Use to test whether one `BigDecimal` is strictly less than another.
 *
 * **Example** (Checking less-than comparisons)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const two = BigDecimal.fromStringUnsafe("2")
 * const three = BigDecimal.fromStringUnsafe("3")
 * const four = BigDecimal.fromStringUnsafe("4")
 *
 * BigDecimal.isLessThan(two, three) // => true
 * BigDecimal.isLessThan(three, three) // => false
 * BigDecimal.isLessThan(four, three) // => false
 * ```
 *
 * @stability stable
 * @category predicates
 * @since 4.0.0
 */
export declare const isLessThan: {
    /**
     * Returns `true` if the first argument is less than the second, otherwise `false`.
     *
     * **When to use**
     *
     * Use to test whether one `BigDecimal` is strictly less than another.
     *
     * **Example** (Checking less-than comparisons)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const four = BigDecimal.fromStringUnsafe("4")
     *
     * BigDecimal.isLessThan(two, three) // => true
     * BigDecimal.isLessThan(three, three) // => false
     * BigDecimal.isLessThan(four, three) // => false
     * ```
     *
     * @stability stable
     * @category predicates
     * @since 4.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => boolean;
    /**
     * Returns `true` if the first argument is less than the second, otherwise `false`.
     *
     * **When to use**
     *
     * Use to test whether one `BigDecimal` is strictly less than another.
     *
     * **Example** (Checking less-than comparisons)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const four = BigDecimal.fromStringUnsafe("4")
     *
     * BigDecimal.isLessThan(two, three) // => true
     * BigDecimal.isLessThan(three, three) // => false
     * BigDecimal.isLessThan(four, three) // => false
     * ```
     *
     * @stability stable
     * @category predicates
     * @since 4.0.0
     */
    (self: BigDecimal, that: BigDecimal): boolean;
};
/**
 * Checks whether a given `BigDecimal` is less than or equal to the provided one.
 *
 * **When to use**
 *
 * Use to test whether one `BigDecimal` is less than or equal to another.
 *
 * **Example** (Checking less-than-or-equal comparisons)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const two = BigDecimal.fromStringUnsafe("2")
 * const three = BigDecimal.fromStringUnsafe("3")
 * const four = BigDecimal.fromStringUnsafe("4")
 *
 * BigDecimal.isLessThanOrEqualTo(two, three) // => true
 * BigDecimal.isLessThanOrEqualTo(three, three) // => true
 * BigDecimal.isLessThanOrEqualTo(four, three) // => false
 * ```
 *
 * @stability stable
 * @category predicates
 * @since 4.0.0
 */
export declare const isLessThanOrEqualTo: {
    /**
     * Checks whether a given `BigDecimal` is less than or equal to the provided one.
     *
     * **When to use**
     *
     * Use to test whether one `BigDecimal` is less than or equal to another.
     *
     * **Example** (Checking less-than-or-equal comparisons)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const four = BigDecimal.fromStringUnsafe("4")
     *
     * BigDecimal.isLessThanOrEqualTo(two, three) // => true
     * BigDecimal.isLessThanOrEqualTo(three, three) // => true
     * BigDecimal.isLessThanOrEqualTo(four, three) // => false
     * ```
     *
     * @stability stable
     * @category predicates
     * @since 4.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => boolean;
    /**
     * Checks whether a given `BigDecimal` is less than or equal to the provided one.
     *
     * **When to use**
     *
     * Use to test whether one `BigDecimal` is less than or equal to another.
     *
     * **Example** (Checking less-than-or-equal comparisons)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const four = BigDecimal.fromStringUnsafe("4")
     *
     * BigDecimal.isLessThanOrEqualTo(two, three) // => true
     * BigDecimal.isLessThanOrEqualTo(three, three) // => true
     * BigDecimal.isLessThanOrEqualTo(four, three) // => false
     * ```
     *
     * @stability stable
     * @category predicates
     * @since 4.0.0
     */
    (self: BigDecimal, that: BigDecimal): boolean;
};
/**
 * Returns `true` if the first argument is greater than the second, otherwise `false`.
 *
 * **When to use**
 *
 * Use to test whether one `BigDecimal` is strictly greater than another.
 *
 * **Example** (Checking greater-than comparisons)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const two = BigDecimal.fromStringUnsafe("2")
 * const three = BigDecimal.fromStringUnsafe("3")
 * const four = BigDecimal.fromStringUnsafe("4")
 *
 * BigDecimal.isGreaterThan(two, three) // => false
 * BigDecimal.isGreaterThan(three, three) // => false
 * BigDecimal.isGreaterThan(four, three) // => true
 * ```
 *
 * @stability stable
 * @category predicates
 * @since 4.0.0
 */
export declare const isGreaterThan: {
    /**
     * Returns `true` if the first argument is greater than the second, otherwise `false`.
     *
     * **When to use**
     *
     * Use to test whether one `BigDecimal` is strictly greater than another.
     *
     * **Example** (Checking greater-than comparisons)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const four = BigDecimal.fromStringUnsafe("4")
     *
     * BigDecimal.isGreaterThan(two, three) // => false
     * BigDecimal.isGreaterThan(three, three) // => false
     * BigDecimal.isGreaterThan(four, three) // => true
     * ```
     *
     * @stability stable
     * @category predicates
     * @since 4.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => boolean;
    /**
     * Returns `true` if the first argument is greater than the second, otherwise `false`.
     *
     * **When to use**
     *
     * Use to test whether one `BigDecimal` is strictly greater than another.
     *
     * **Example** (Checking greater-than comparisons)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const four = BigDecimal.fromStringUnsafe("4")
     *
     * BigDecimal.isGreaterThan(two, three) // => false
     * BigDecimal.isGreaterThan(three, three) // => false
     * BigDecimal.isGreaterThan(four, three) // => true
     * ```
     *
     * @stability stable
     * @category predicates
     * @since 4.0.0
     */
    (self: BigDecimal, that: BigDecimal): boolean;
};
/**
 * Checks whether a given `BigDecimal` is greater than or equal to the provided one.
 *
 * **When to use**
 *
 * Use to test whether one `BigDecimal` is greater than or equal to another.
 *
 * **Example** (Checking greater-than-or-equal comparisons)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const two = BigDecimal.fromStringUnsafe("2")
 * const three = BigDecimal.fromStringUnsafe("3")
 * const four = BigDecimal.fromStringUnsafe("4")
 *
 * BigDecimal.isGreaterThanOrEqualTo(two, three) // => false
 * BigDecimal.isGreaterThanOrEqualTo(three, three) // => true
 * BigDecimal.isGreaterThanOrEqualTo(four, three) // => true
 * ```
 *
 * @stability stable
 * @category predicates
 * @since 4.0.0
 */
export declare const isGreaterThanOrEqualTo: {
    /**
     * Checks whether a given `BigDecimal` is greater than or equal to the provided one.
     *
     * **When to use**
     *
     * Use to test whether one `BigDecimal` is greater than or equal to another.
     *
     * **Example** (Checking greater-than-or-equal comparisons)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const four = BigDecimal.fromStringUnsafe("4")
     *
     * BigDecimal.isGreaterThanOrEqualTo(two, three) // => false
     * BigDecimal.isGreaterThanOrEqualTo(three, three) // => true
     * BigDecimal.isGreaterThanOrEqualTo(four, three) // => true
     * ```
     *
     * @stability stable
     * @category predicates
     * @since 4.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => boolean;
    /**
     * Checks whether a given `BigDecimal` is greater than or equal to the provided one.
     *
     * **When to use**
     *
     * Use to test whether one `BigDecimal` is greater than or equal to another.
     *
     * **Example** (Checking greater-than-or-equal comparisons)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const four = BigDecimal.fromStringUnsafe("4")
     *
     * BigDecimal.isGreaterThanOrEqualTo(two, three) // => false
     * BigDecimal.isGreaterThanOrEqualTo(three, three) // => true
     * BigDecimal.isGreaterThanOrEqualTo(four, three) // => true
     * ```
     *
     * @stability stable
     * @category predicates
     * @since 4.0.0
     */
    (self: BigDecimal, that: BigDecimal): boolean;
};
/**
 * Checks whether a `BigDecimal` is between a `minimum` and `maximum` value (inclusive).
 *
 * **When to use**
 *
 * Use to test whether a `BigDecimal` falls inside an inclusive range.
 *
 * **Example** (Checking decimal ranges)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const between = BigDecimal.between({
 *   minimum: BigDecimal.fromStringUnsafe("1"),
 *   maximum: BigDecimal.fromStringUnsafe("5")
 * })
 *
 * between(BigDecimal.fromStringUnsafe("3")) // => true
 * between(BigDecimal.fromStringUnsafe("0")) // => false
 * between(BigDecimal.fromStringUnsafe("6")) // => false
 * ```
 *
 * @see {@link clamp} for forcing a `BigDecimal` into an inclusive range
 *
 * @stability stable
 * @category predicates
 * @since 2.0.0
 */
export declare const between: {
    /**
     * Checks whether a `BigDecimal` is between a `minimum` and `maximum` value (inclusive).
     *
     * **When to use**
     *
     * Use to test whether a `BigDecimal` falls inside an inclusive range.
     *
     * **Example** (Checking decimal ranges)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const between = BigDecimal.between({
     *   minimum: BigDecimal.fromStringUnsafe("1"),
     *   maximum: BigDecimal.fromStringUnsafe("5")
     * })
     *
     * between(BigDecimal.fromStringUnsafe("3")) // => true
     * between(BigDecimal.fromStringUnsafe("0")) // => false
     * between(BigDecimal.fromStringUnsafe("6")) // => false
     * ```
     *
     * @see {@link clamp} for forcing a `BigDecimal` into an inclusive range
     *
     * @stability stable
     * @category predicates
     * @since 2.0.0
     */
    (options: {
        minimum: BigDecimal;
        maximum: BigDecimal;
    }): (self: BigDecimal) => boolean;
    /**
     * Checks whether a `BigDecimal` is between a `minimum` and `maximum` value (inclusive).
     *
     * **When to use**
     *
     * Use to test whether a `BigDecimal` falls inside an inclusive range.
     *
     * **Example** (Checking decimal ranges)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const between = BigDecimal.between({
     *   minimum: BigDecimal.fromStringUnsafe("1"),
     *   maximum: BigDecimal.fromStringUnsafe("5")
     * })
     *
     * between(BigDecimal.fromStringUnsafe("3")) // => true
     * between(BigDecimal.fromStringUnsafe("0")) // => false
     * between(BigDecimal.fromStringUnsafe("6")) // => false
     * ```
     *
     * @see {@link clamp} for forcing a `BigDecimal` into an inclusive range
     *
     * @stability stable
     * @category predicates
     * @since 2.0.0
     */
    (self: BigDecimal, options: {
        minimum: BigDecimal;
        maximum: BigDecimal;
    }): boolean;
};
/**
 * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values.
 *
 * **When to use**
 *
 * Use to force a `BigDecimal` into an inclusive range.
 *
 * **Details**
 *
 * If the `BigDecimal` is less than the `minimum` value, the function returns
 * the `minimum` value. If it is greater than the `maximum` value, the function
 * returns the `maximum` value. Otherwise, it returns the original `BigDecimal`.
 *
 * **Example** (Clamping decimals to a range)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const clamp = BigDecimal.clamp({
 *   minimum: BigDecimal.fromStringUnsafe("1"),
 *   maximum: BigDecimal.fromStringUnsafe("5")
 * })
 *
 * clamp(BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(3n)
 * clamp(BigDecimal.fromStringUnsafe("0")) // => BigDecimal.fromBigInt(1n)
 * clamp(BigDecimal.fromStringUnsafe("6")) // => BigDecimal.fromBigInt(5n)
 * ```
 *
 * @see {@link between} for checking whether a `BigDecimal` is already inside a range
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const clamp: {
    /**
     * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values.
     *
     * **When to use**
     *
     * Use to force a `BigDecimal` into an inclusive range.
     *
     * **Details**
     *
     * If the `BigDecimal` is less than the `minimum` value, the function returns
     * the `minimum` value. If it is greater than the `maximum` value, the function
     * returns the `maximum` value. Otherwise, it returns the original `BigDecimal`.
     *
     * **Example** (Clamping decimals to a range)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const clamp = BigDecimal.clamp({
     *   minimum: BigDecimal.fromStringUnsafe("1"),
     *   maximum: BigDecimal.fromStringUnsafe("5")
     * })
     *
     * clamp(BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(3n)
     * clamp(BigDecimal.fromStringUnsafe("0")) // => BigDecimal.fromBigInt(1n)
     * clamp(BigDecimal.fromStringUnsafe("6")) // => BigDecimal.fromBigInt(5n)
     * ```
     *
     * @see {@link between} for checking whether a `BigDecimal` is already inside a range
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (options: {
        minimum: BigDecimal;
        maximum: BigDecimal;
    }): (self: BigDecimal) => BigDecimal;
    /**
     * Restricts the given `BigDecimal` to be within the range specified by the `minimum` and `maximum` values.
     *
     * **When to use**
     *
     * Use to force a `BigDecimal` into an inclusive range.
     *
     * **Details**
     *
     * If the `BigDecimal` is less than the `minimum` value, the function returns
     * the `minimum` value. If it is greater than the `maximum` value, the function
     * returns the `maximum` value. Otherwise, it returns the original `BigDecimal`.
     *
     * **Example** (Clamping decimals to a range)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const clamp = BigDecimal.clamp({
     *   minimum: BigDecimal.fromStringUnsafe("1"),
     *   maximum: BigDecimal.fromStringUnsafe("5")
     * })
     *
     * clamp(BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(3n)
     * clamp(BigDecimal.fromStringUnsafe("0")) // => BigDecimal.fromBigInt(1n)
     * clamp(BigDecimal.fromStringUnsafe("6")) // => BigDecimal.fromBigInt(5n)
     * ```
     *
     * @see {@link between} for checking whether a `BigDecimal` is already inside a range
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (self: BigDecimal, options: {
        minimum: BigDecimal;
        maximum: BigDecimal;
    }): BigDecimal;
};
/**
 * Returns the minimum between two `BigDecimal`s.
 *
 * **When to use**
 *
 * Use to select the smaller of two `BigDecimal` values.
 *
 * **Example** (Selecting the smaller decimal)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const result = BigDecimal.min(
 *   BigDecimal.fromStringUnsafe("2"),
 *   BigDecimal.fromStringUnsafe("3")
 * ) // => BigDecimal.fromBigInt(2n)
 * ```
 *
 * @see {@link max} for selecting the larger value
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const min: {
    /**
     * Returns the minimum between two `BigDecimal`s.
     *
     * **When to use**
     *
     * Use to select the smaller of two `BigDecimal` values.
     *
     * **Example** (Selecting the smaller decimal)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.min(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(2n)
     * ```
     *
     * @see {@link max} for selecting the larger value
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
    /**
     * Returns the minimum between two `BigDecimal`s.
     *
     * **When to use**
     *
     * Use to select the smaller of two `BigDecimal` values.
     *
     * **Example** (Selecting the smaller decimal)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.min(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(2n)
     * ```
     *
     * @see {@link max} for selecting the larger value
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (self: BigDecimal, that: BigDecimal): BigDecimal;
};
/**
 * Returns the maximum between two `BigDecimal`s.
 *
 * **When to use**
 *
 * Use to select the larger of two `BigDecimal` values.
 *
 * **Example** (Selecting the larger decimal)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const result = BigDecimal.max(
 *   BigDecimal.fromStringUnsafe("2"),
 *   BigDecimal.fromStringUnsafe("3")
 * ) // => BigDecimal.fromBigInt(3n)
 * ```
 *
 * @see {@link min} for selecting the smaller value
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const max: {
    /**
     * Returns the maximum between two `BigDecimal`s.
     *
     * **When to use**
     *
     * Use to select the larger of two `BigDecimal` values.
     *
     * **Example** (Selecting the larger decimal)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.max(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(3n)
     * ```
     *
     * @see {@link min} for selecting the smaller value
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => BigDecimal;
    /**
     * Returns the maximum between two `BigDecimal`s.
     *
     * **When to use**
     *
     * Use to select the larger of two `BigDecimal` values.
     *
     * **Example** (Selecting the larger decimal)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const result = BigDecimal.max(
     *   BigDecimal.fromStringUnsafe("2"),
     *   BigDecimal.fromStringUnsafe("3")
     * ) // => BigDecimal.fromBigInt(3n)
     * ```
     *
     * @see {@link min} for selecting the smaller value
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (self: BigDecimal, that: BigDecimal): BigDecimal;
};
/**
 * Determines the sign of a given `BigDecimal`.
 *
 * **When to use**
 *
 * Use to classify a `BigDecimal` as negative, zero, or positive.
 *
 * **Example** (Reading decimal signs)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.sign(BigDecimal.fromStringUnsafe("-5")) // => -1
 * BigDecimal.sign(BigDecimal.fromStringUnsafe("0")) // => 0
 * BigDecimal.sign(BigDecimal.fromStringUnsafe("5")) // => 1
 * ```
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const sign: (n: BigDecimal) => Ordering;
/**
 * Determines the absolute value of a given `BigDecimal`.
 *
 * **When to use**
 *
 * Use to remove the sign from a `BigDecimal` while preserving its magnitude.
 *
 * **Example** (Calculating absolute values)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.abs(BigDecimal.fromStringUnsafe("-5")) // => BigDecimal.fromBigInt(5n)
 * BigDecimal.abs(BigDecimal.fromStringUnsafe("0")) // => BigDecimal.fromBigInt(0n)
 * BigDecimal.abs(BigDecimal.fromStringUnsafe("5")) // => BigDecimal.fromBigInt(5n)
 * ```
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const abs: (n: BigDecimal) => BigDecimal;
/**
 * Provides a negate operation on `BigDecimal`s.
 *
 * **When to use**
 *
 * Use to flip the sign of a `BigDecimal`.
 *
 * **Example** (Negating decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.negate(BigDecimal.fromStringUnsafe("3")) // => BigDecimal.fromBigInt(-3n)
 * BigDecimal.negate(BigDecimal.fromStringUnsafe("-6")) // => BigDecimal.fromBigInt(6n)
 * ```
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const negate: (n: BigDecimal) => BigDecimal;
/**
 * Computes the decimal remainder safely when one operand is divided by a second
 * operand.
 *
 * **When to use**
 *
 * Use to compute a decimal remainder while representing division by zero as
 * `Option.none`.
 *
 * **Details**
 *
 * If the divisor is `0`, the result will be `Option.none()`.
 *
 * **Example** (Computing remainders safely)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal, Option } from "effect"
 *
 * const two = BigDecimal.fromStringUnsafe("2")
 * const three = BigDecimal.fromStringUnsafe("3")
 * const zero = BigDecimal.fromStringUnsafe("0")
 *
 * BigDecimal.remainder(three, two) // => Option.some(BigDecimal.fromBigInt(1n))
 * BigDecimal.remainder(two, zero) // => Option.none()
 * ```
 *
 * @see {@link remainderUnsafe} for remainder calculation that throws when the divisor is zero
 * @see {@link divide} for decimal quotient calculation
 *
 * @stability stable
 * @category math
 * @since 2.0.0
 */
export declare const remainder: {
    /**
     * Computes the decimal remainder safely when one operand is divided by a second
     * operand.
     *
     * **When to use**
     *
     * Use to compute a decimal remainder while representing division by zero as
     * `Option.none`.
     *
     * **Details**
     *
     * If the divisor is `0`, the result will be `Option.none()`.
     *
     * **Example** (Computing remainders safely)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal, Option } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const zero = BigDecimal.fromStringUnsafe("0")
     *
     * BigDecimal.remainder(three, two) // => Option.some(BigDecimal.fromBigInt(1n))
     * BigDecimal.remainder(two, zero) // => Option.none()
     * ```
     *
     * @see {@link remainderUnsafe} for remainder calculation that throws when the divisor is zero
     * @see {@link divide} for decimal quotient calculation
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (divisor: BigDecimal): (self: BigDecimal) => Option.Option<BigDecimal>;
    /**
     * Computes the decimal remainder safely when one operand is divided by a second
     * operand.
     *
     * **When to use**
     *
     * Use to compute a decimal remainder while representing division by zero as
     * `Option.none`.
     *
     * **Details**
     *
     * If the divisor is `0`, the result will be `Option.none()`.
     *
     * **Example** (Computing remainders safely)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal, Option } from "effect"
     *
     * const two = BigDecimal.fromStringUnsafe("2")
     * const three = BigDecimal.fromStringUnsafe("3")
     * const zero = BigDecimal.fromStringUnsafe("0")
     *
     * BigDecimal.remainder(three, two) // => Option.some(BigDecimal.fromBigInt(1n))
     * BigDecimal.remainder(two, zero) // => Option.none()
     * ```
     *
     * @see {@link remainderUnsafe} for remainder calculation that throws when the divisor is zero
     * @see {@link divide} for decimal quotient calculation
     *
     * @stability stable
     * @category math
     * @since 2.0.0
     */
    (self: BigDecimal, divisor: BigDecimal): Option.Option<BigDecimal>;
};
/**
 * Returns the decimal remainder left over when one operand is divided by a
 * non-zero second operand.
 *
 * **When to use**
 *
 * Use when you need to compute a `BigDecimal` remainder with a divisor known to
 * be non-zero and want a plain `BigDecimal` result instead of an `Option`.
 *
 * **Gotchas**
 *
 * Throws a `RangeError` if the divisor is `0`.
 *
 * **Example** (Computing remainders unsafely)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.remainderUnsafe(
 *   BigDecimal.fromStringUnsafe("3"),
 *   BigDecimal.fromStringUnsafe("2")
 * ) // => BigDecimal.fromBigInt(1n)
 * ```
 *
 * @see {@link remainder} for returning `Option.none` when the divisor is zero
 *
 * @stability stable
 * @category math
 * @since 4.0.0
 */
export declare const remainderUnsafe: {
    /**
     * Returns the decimal remainder left over when one operand is divided by a
     * non-zero second operand.
     *
     * **When to use**
     *
     * Use when you need to compute a `BigDecimal` remainder with a divisor known to
     * be non-zero and want a plain `BigDecimal` result instead of an `Option`.
     *
     * **Gotchas**
     *
     * Throws a `RangeError` if the divisor is `0`.
     *
     * **Example** (Computing remainders unsafely)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.remainderUnsafe(
     *   BigDecimal.fromStringUnsafe("3"),
     *   BigDecimal.fromStringUnsafe("2")
     * ) // => BigDecimal.fromBigInt(1n)
     * ```
     *
     * @see {@link remainder} for returning `Option.none` when the divisor is zero
     *
     * @stability stable
     * @category math
     * @since 4.0.0
     */
    (divisor: BigDecimal): (self: BigDecimal) => BigDecimal;
    /**
     * Returns the decimal remainder left over when one operand is divided by a
     * non-zero second operand.
     *
     * **When to use**
     *
     * Use when you need to compute a `BigDecimal` remainder with a divisor known to
     * be non-zero and want a plain `BigDecimal` result instead of an `Option`.
     *
     * **Gotchas**
     *
     * Throws a `RangeError` if the divisor is `0`.
     *
     * **Example** (Computing remainders unsafely)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.remainderUnsafe(
     *   BigDecimal.fromStringUnsafe("3"),
     *   BigDecimal.fromStringUnsafe("2")
     * ) // => BigDecimal.fromBigInt(1n)
     * ```
     *
     * @see {@link remainder} for returning `Option.none` when the divisor is zero
     *
     * @stability stable
     * @category math
     * @since 4.0.0
     */
    (self: BigDecimal, divisor: BigDecimal): BigDecimal;
};
/**
 * Provides an `Equivalence` instance for `BigDecimal` that determines equality between BigDecimal values.
 *
 * **When to use**
 *
 * Use when comparing decimal values through APIs that accept an equivalence
 * relation.
 *
 * **Example** (Checking decimal equivalence)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const a = BigDecimal.fromStringUnsafe("1.50")
 * const b = BigDecimal.fromStringUnsafe("1.5")
 * const c = BigDecimal.fromStringUnsafe("2.0")
 *
 * BigDecimal.Equivalence(a, b) // => true
 * BigDecimal.Equivalence(a, c) // => false
 * ```
 *
 * @stability stable
 * @category instances
 * @since 2.0.0
 */
export declare const Equivalence: Equ.Equivalence<BigDecimal>;
/**
 * Checks whether two `BigDecimal`s are equal.
 *
 * **When to use**
 *
 * Use to compare two `BigDecimal` values for numeric equality.
 *
 * **Example** (Checking decimal equality)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const a = BigDecimal.fromStringUnsafe("1.5")
 * const b = BigDecimal.fromStringUnsafe("1.50")
 * const c = BigDecimal.fromStringUnsafe("2.0")
 *
 * BigDecimal.equals(a, b) // => true
 * BigDecimal.equals(a, c) // => false
 * ```
 *
 * @see {@link Equivalence} for passing decimal equality to APIs that require an `Equivalence`
 *
 * @stability stable
 * @category predicates
 * @since 2.0.0
 */
export declare const equals: {
    /**
     * Checks whether two `BigDecimal`s are equal.
     *
     * **When to use**
     *
     * Use to compare two `BigDecimal` values for numeric equality.
     *
     * **Example** (Checking decimal equality)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const a = BigDecimal.fromStringUnsafe("1.5")
     * const b = BigDecimal.fromStringUnsafe("1.50")
     * const c = BigDecimal.fromStringUnsafe("2.0")
     *
     * BigDecimal.equals(a, b) // => true
     * BigDecimal.equals(a, c) // => false
     * ```
     *
     * @see {@link Equivalence} for passing decimal equality to APIs that require an `Equivalence`
     *
     * @stability stable
     * @category predicates
     * @since 2.0.0
     */
    (that: BigDecimal): (self: BigDecimal) => boolean;
    /**
     * Checks whether two `BigDecimal`s are equal.
     *
     * **When to use**
     *
     * Use to compare two `BigDecimal` values for numeric equality.
     *
     * **Example** (Checking decimal equality)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const a = BigDecimal.fromStringUnsafe("1.5")
     * const b = BigDecimal.fromStringUnsafe("1.50")
     * const c = BigDecimal.fromStringUnsafe("2.0")
     *
     * BigDecimal.equals(a, b) // => true
     * BigDecimal.equals(a, c) // => false
     * ```
     *
     * @see {@link Equivalence} for passing decimal equality to APIs that require an `Equivalence`
     *
     * @stability stable
     * @category predicates
     * @since 2.0.0
     */
    (self: BigDecimal, that: BigDecimal): boolean;
};
/**
 * Creates a `BigDecimal` from a `bigint` value.
 *
 * **When to use**
 *
 * Use to construct an integer `BigDecimal` from a `bigint`.
 *
 * **Example** (Creating decimals from bigint)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const decimal = BigDecimal.fromBigInt(123n)
 * decimal // => BigDecimal.fromStringUnsafe("123")
 *
 * const largeBigInt = BigDecimal.fromBigInt(9007199254740991n)
 * largeBigInt // => BigDecimal.fromStringUnsafe("9007199254740991")
 * ```
 *
 * @see {@link make} for constructing a decimal with an explicit scale
 *
 * @stability stable
 * @category constructors
 * @since 2.0.0
 */
export declare const fromBigInt: (n: bigint) => BigDecimal;
/**
 * Creates a `BigDecimal` from a finite `number`.
 *
 * **When to use**
 *
 * Use when you need to convert a trusted finite JavaScript number to a
 * `BigDecimal` and want a plain result instead of an `Option`.
 *
 * **Gotchas**
 *
 * It is not recommended to convert a floating point number to a decimal
 * directly, as the floating point representation may be unexpected. Throws a
 * `RangeError` if the number is not finite (`NaN`, `+Infinity` or `-Infinity`).
 *
 * **Example** (Creating decimals from finite numbers)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.fromNumberUnsafe(123) // => BigDecimal.fromBigInt(123n)
 * BigDecimal.fromNumberUnsafe(123.456) // => BigDecimal.fromStringUnsafe("123.456")
 * ```
 *
 * @see {@link fromNumber} for returning `Option.none` when the number is not finite
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare const fromNumberUnsafe: (n: number) => BigDecimal;
/**
 * Creates a `BigDecimal` safely from a finite `number`.
 *
 * **When to use**
 *
 * Use to convert a finite JavaScript number to a `BigDecimal` without throwing
 * on invalid input.
 *
 * **Details**
 *
 * Returns `Option.none()` for `NaN`, `+Infinity` or `-Infinity`.
 *
 * **Gotchas**
 *
 * It is not recommended to convert a floating point number to a decimal
 * directly, as the floating point representation may be unexpected.
 *
 * **Example** (Creating decimals from numbers safely)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal, Option } from "effect"
 *
 * BigDecimal.fromNumber(123.456) // => Option.some(BigDecimal.fromStringUnsafe("123.456"))
 * BigDecimal.fromNumber(Infinity) // => Option.none()
 * ```
 *
 * @see {@link fromNumberUnsafe} for throwing when the number is not finite
 * @see {@link fromString} for parsing decimal strings directly
 *
 * @stability stable
 * @category constructors
 * @since 2.0.0
 */
export declare const fromNumber: (n: number) => Option.Option<BigDecimal>;
/**
 * Parses a decimal string into a `BigDecimal` safely.
 *
 * **When to use**
 *
 * Use to parse external decimal text without throwing on invalid input.
 *
 * **Details**
 *
 * Returns `Option.some` for valid decimal or exponent notation and
 * `Option.none` when the string cannot be parsed or would produce an unsafe
 * scale. The empty string parses as zero.
 *
 * **Example** (Parsing decimal strings safely)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal, Option } from "effect"
 *
 * BigDecimal.fromString("123.456") // => Option.some(BigDecimal.make(123456n, 3))
 * BigDecimal.fromString("123.abc") // => Option.none()
 * ```
 *
 * @see {@link fromStringUnsafe} for parsing that throws on invalid input
 * @see {@link fromNumber} for converting finite JavaScript numbers
 *
 * @stability stable
 * @category constructors
 * @since 2.0.0
 */
export declare const fromString: (s: string) => Option.Option<BigDecimal>;
/**
 * Parses a decimal string into a `BigDecimal`, throwing if the string is
 * invalid.
 *
 * **When to use**
 *
 * Use when you expect decimal text to be valid and want parse errors to throw.
 *
 * **Details**
 *
 * Accepts the same syntax as `fromString`. Use `fromString` when invalid input
 * should be represented as `Option.none` instead of throwing.
 *
 * **Example** (Parsing decimal strings unsafely)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.fromStringUnsafe("123") // => BigDecimal.fromBigInt(123n)
 * BigDecimal.fromStringUnsafe("123.456") // => BigDecimal.make(123456n, 3)
 * ```
 *
 * @see {@link fromString} for returning `Option.none` on invalid input
 *
 * @stability stable
 * @category constructors
 * @since 4.0.0
 */
export declare const fromStringUnsafe: (s: string) => BigDecimal;
/**
 * Formats a `BigDecimal` as a string.
 *
 * **When to use**
 *
 * Use to render a `BigDecimal` as plain decimal text when possible.
 *
 * **Details**
 *
 * The value is normalized before formatting. Scientific notation is used when
 * the absolute value of the normalized scale is at least `16`; otherwise plain
 * decimal notation is used.
 *
 * **Example** (Formatting decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.format(BigDecimal.fromStringUnsafe("-5")) // => "-5"
 * BigDecimal.format(BigDecimal.fromStringUnsafe("123.456")) // => "123.456"
 * BigDecimal.format(BigDecimal.fromStringUnsafe("-0.00000123")) // => "-0.00000123"
 * ```
 *
 * @see {@link toExponential} for always rendering scientific notation
 *
 * @stability stable
 * @category converting
 * @since 2.0.0
 */
export declare const format: (n: BigDecimal) => string;
/**
 * Formats a given `BigDecimal` as a `string` in scientific notation.
 *
 * **When to use**
 *
 * Use to render a `BigDecimal` in scientific notation.
 *
 * **Example** (Formatting decimals exponentially)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.toExponential(BigDecimal.make(123456n, -5)) // => "1.23456e+10"
 * ```
 *
 * @see {@link format} for plain decimal formatting when possible
 *
 * @stability stable
 * @category converting
 * @since 3.11.0
 */
export declare const toExponential: (n: BigDecimal) => string;
/**
 * Converts a `BigDecimal` to a JavaScript `number`.
 *
 * **When to use**
 *
 * Use when you need a JavaScript number at an interop boundary where precision
 * loss is acceptable.
 *
 * **Gotchas**
 *
 * This conversion is unsafe because the result can lose integer or fractional
 * precision, round to a nearby representable value, or become `Infinity` when
 * the decimal cannot be represented as a finite JavaScript `number`.
 *
 * **Example** (Converting decimals to numbers)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.toNumberUnsafe(BigDecimal.fromStringUnsafe("123.456")) // => 123.456
 * ```
 *
 * @see {@link format} for preserving decimal precision as text
 *
 * @stability stable
 * @category converting
 * @since 4.0.0
 */
export declare const toNumberUnsafe: (n: BigDecimal) => number;
/**
 * Checks whether a given `BigDecimal` is an integer.
 *
 * **When to use**
 *
 * Use to test whether a `BigDecimal` has no fractional decimal part.
 *
 * **Example** (Checking integer decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.isInteger(BigDecimal.fromStringUnsafe("0")) // => true
 * BigDecimal.isInteger(BigDecimal.fromStringUnsafe("1")) // => true
 * BigDecimal.isInteger(BigDecimal.fromStringUnsafe("1.1")) // => false
 * ```
 *
 * @stability stable
 * @category predicates
 * @since 2.0.0
 */
export declare const isInteger: (n: BigDecimal) => boolean;
/**
 * Checks whether a given `BigDecimal` is `0`.
 *
 * **When to use**
 *
 * Use to test whether a `BigDecimal` is exactly zero.
 *
 * **Example** (Checking zero decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.isZero(BigDecimal.fromStringUnsafe("0")) // => true
 * BigDecimal.isZero(BigDecimal.fromStringUnsafe("1")) // => false
 * ```
 *
 * @stability stable
 * @category predicates
 * @since 2.0.0
 */
export declare const isZero: (n: BigDecimal) => boolean;
/**
 * Checks whether a given `BigDecimal` is negative.
 *
 * **When to use**
 *
 * Use to test whether a `BigDecimal` is less than zero.
 *
 * **Example** (Checking negative decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.isNegative(BigDecimal.fromStringUnsafe("-1")) // => true
 * BigDecimal.isNegative(BigDecimal.fromStringUnsafe("0")) // => false
 * BigDecimal.isNegative(BigDecimal.fromStringUnsafe("1")) // => false
 * ```
 *
 * @stability stable
 * @category predicates
 * @since 2.0.0
 */
export declare const isNegative: (n: BigDecimal) => boolean;
/**
 * Checks whether a given `BigDecimal` is positive.
 *
 * **When to use**
 *
 * Use to test whether a `BigDecimal` is greater than zero.
 *
 * **Example** (Checking positive decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.isPositive(BigDecimal.fromStringUnsafe("-1")) // => false
 * BigDecimal.isPositive(BigDecimal.fromStringUnsafe("0")) // => false
 * BigDecimal.isPositive(BigDecimal.fromStringUnsafe("1")) // => true
 * ```
 *
 * @stability stable
 * @category predicates
 * @since 2.0.0
 */
export declare const isPositive: (n: BigDecimal) => boolean;
/**
 * Rounding modes for `BigDecimal`.
 *
 * **When to use**
 *
 * Use with `round` to choose how discarded digits affect a `BigDecimal`
 * rounded to a target scale.
 *
 * **Details**
 *
 * - `ceil`: round towards positive infinity
 * - `floor`: round towards negative infinity
 * - `to-zero`: round towards zero
 * - `from-zero`: round away from zero
 * - `half-ceil`: round to the nearest neighbor; if equidistant round towards positive infinity
 * - `half-floor`: round to the nearest neighbor; if equidistant round towards negative infinity
 * - `half-to-zero`: round to the nearest neighbor; if equidistant round towards zero
 * - `half-from-zero`: round to the nearest neighbor; if equidistant round away from zero
 * - `half-even`: round to the nearest neighbor; if equidistant round to the neighbor with an even digit
 * - `half-odd`: round to the nearest neighbor; if equidistant round to the neighbor with an odd digit
 *
 * @see {@link round} for configurable rounding with a `RoundingMode`
 * @see {@link ceil} for fixed rounding toward positive infinity
 * @see {@link floor} for fixed rounding toward negative infinity
 * @see {@link truncate} for fixed rounding toward zero
 *
 * @stability stable
 * @category math
 * @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";
/**
 * Computes a rounded `BigDecimal` at the given scale with the specified rounding mode.
 *
 * **When to use**
 *
 * Use to round a decimal at a requested scale with an explicit rounding mode.
 *
 * **Example** (Rounding decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * const positive = BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 })
 * positive // => BigDecimal.fromBigInt(150n)
 *
 * const negative = BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5"))
 * negative // => BigDecimal.fromBigInt(-15n)
 * ```
 *
 * @see {@link ceil} for fixed rounding toward positive infinity
 * @see {@link floor} for fixed rounding toward negative infinity
 * @see {@link truncate} for fixed rounding toward zero
 *
 * @stability stable
 * @category math
 * @since 3.16.0
 */
export declare const round: {
    /**
     * Computes a rounded `BigDecimal` at the given scale with the specified rounding mode.
     *
     * **When to use**
     *
     * Use to round a decimal at a requested scale with an explicit rounding mode.
     *
     * **Example** (Rounding decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const positive = BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 })
     * positive // => BigDecimal.fromBigInt(150n)
     *
     * const negative = BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5"))
     * negative // => BigDecimal.fromBigInt(-15n)
     * ```
     *
     * @see {@link ceil} for fixed rounding toward positive infinity
     * @see {@link floor} for fixed rounding toward negative infinity
     * @see {@link truncate} for fixed rounding toward zero
     *
     * @stability stable
     * @category math
     * @since 3.16.0
     */
    (options: {
        scale?: number;
        mode?: RoundingMode;
    }): (self: BigDecimal) => BigDecimal;
    /**
     * Computes a rounded `BigDecimal` at the given scale with the specified rounding mode.
     *
     * **When to use**
     *
     * Use to round a decimal at a requested scale with an explicit rounding mode.
     *
     * **Example** (Rounding decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * const positive = BigDecimal.round(BigDecimal.fromStringUnsafe("145"), { mode: "from-zero", scale: -1 })
     * positive // => BigDecimal.fromBigInt(150n)
     *
     * const negative = BigDecimal.round(BigDecimal.fromStringUnsafe("-14.5"))
     * negative // => BigDecimal.fromBigInt(-15n)
     * ```
     *
     * @see {@link ceil} for fixed rounding toward positive infinity
     * @see {@link floor} for fixed rounding toward negative infinity
     * @see {@link truncate} for fixed rounding toward zero
     *
     * @stability stable
     * @category math
     * @since 3.16.0
     */
    (n: BigDecimal, options?: {
        scale?: number;
        mode?: RoundingMode;
    }): BigDecimal;
};
/**
 * Computes a truncated `BigDecimal` at the given scale. This removes fractional digits beyond the scale,
 * rounding toward zero.
 *
 * **When to use**
 *
 * Use when you need to discard fractional digits beyond a scale rather than
 * round half up, half down, or toward an infinity.
 *
 * **Example** (Truncating decimals)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(140n)
 * BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-14n)
 * ```
 *
 * @see {@link round} for configurable rounding modes
 * @see {@link ceil} for rounding toward positive infinity
 * @see {@link floor} for rounding toward negative infinity
 *
 * @stability stable
 * @category math
 * @since 3.16.0
 */
export declare const truncate: {
    /**
     * Computes a truncated `BigDecimal` at the given scale. This removes fractional digits beyond the scale,
     * rounding toward zero.
     *
     * **When to use**
     *
     * Use when you need to discard fractional digits beyond a scale rather than
     * round half up, half down, or toward an infinity.
     *
     * **Example** (Truncating decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(140n)
     * BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-14n)
     * ```
     *
     * @see {@link round} for configurable rounding modes
     * @see {@link ceil} for rounding toward positive infinity
     * @see {@link floor} for rounding toward negative infinity
     *
     * @stability stable
     * @category math
     * @since 3.16.0
     */
    (scale: number): (self: BigDecimal) => BigDecimal;
    /**
     * Computes a truncated `BigDecimal` at the given scale. This removes fractional digits beyond the scale,
     * rounding toward zero.
     *
     * **When to use**
     *
     * Use when you need to discard fractional digits beyond a scale rather than
     * round half up, half down, or toward an infinity.
     *
     * **Example** (Truncating decimals)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.truncate(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(140n)
     * BigDecimal.truncate(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-14n)
     * ```
     *
     * @see {@link round} for configurable rounding modes
     * @see {@link ceil} for rounding toward positive infinity
     * @see {@link floor} for rounding toward negative infinity
     *
     * @stability stable
     * @category math
     * @since 3.16.0
     */
    (self: BigDecimal, scale?: number): BigDecimal;
};
/**
 * Computes the ceiling of a `BigDecimal` at the given scale.
 *
 * **When to use**
 *
 * Use to round a decimal toward positive infinity at a requested scale.
 *
 * **Details**
 *
 * The default scale is `0`. Positive scales keep digits to the right of the
 * decimal point, and negative scales round positions to the left of the decimal
 * point.
 *
 * @see {@link floor} for rounding toward negative infinity
 * @see {@link truncate} for rounding toward zero
 * @see {@link round} for configurable rounding modes
 *
 * **Example** (Rounding decimals up)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(150n)
 * BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-14n)
 * ```
 *
 * @stability stable
 * @category math
 * @since 3.16.0
 */
export declare const ceil: {
    /**
     * Computes the ceiling of a `BigDecimal` at the given scale.
     *
     * **When to use**
     *
     * Use to round a decimal toward positive infinity at a requested scale.
     *
     * **Details**
     *
     * The default scale is `0`. Positive scales keep digits to the right of the
     * decimal point, and negative scales round positions to the left of the decimal
     * point.
     *
     * @see {@link floor} for rounding toward negative infinity
     * @see {@link truncate} for rounding toward zero
     * @see {@link round} for configurable rounding modes
     *
     * **Example** (Rounding decimals up)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(150n)
     * BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-14n)
     * ```
     *
     * @stability stable
     * @category math
     * @since 3.16.0
     */
    (scale: number): (self: BigDecimal) => BigDecimal;
    /**
     * Computes the ceiling of a `BigDecimal` at the given scale.
     *
     * **When to use**
     *
     * Use to round a decimal toward positive infinity at a requested scale.
     *
     * **Details**
     *
     * The default scale is `0`. Positive scales keep digits to the right of the
     * decimal point, and negative scales round positions to the left of the decimal
     * point.
     *
     * @see {@link floor} for rounding toward negative infinity
     * @see {@link truncate} for rounding toward zero
     * @see {@link round} for configurable rounding modes
     *
     * **Example** (Rounding decimals up)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.ceil(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(150n)
     * BigDecimal.ceil(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-14n)
     * ```
     *
     * @stability stable
     * @category math
     * @since 3.16.0
     */
    (self: BigDecimal, scale?: number): BigDecimal;
};
/**
 * Computes the floor of a `BigDecimal` at the given scale.
 *
 * **When to use**
 *
 * Use to round a decimal toward negative infinity at a requested scale.
 *
 * **Example** (Rounding decimals down)
 *
 * ```ts import.meta.vitest
 * import { BigDecimal } from "effect"
 *
 * BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(140n)
 * BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-15n)
 * ```
 *
 * @see {@link ceil} for rounding toward positive infinity
 * @see {@link truncate} for rounding toward zero
 * @see {@link round} for configurable rounding modes
 *
 * @stability stable
 * @category math
 * @since 3.16.0
 */
export declare const floor: {
    /**
     * Computes the floor of a `BigDecimal` at the given scale.
     *
     * **When to use**
     *
     * Use to round a decimal toward negative infinity at a requested scale.
     *
     * **Example** (Rounding decimals down)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(140n)
     * BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-15n)
     * ```
     *
     * @see {@link ceil} for rounding toward positive infinity
     * @see {@link truncate} for rounding toward zero
     * @see {@link round} for configurable rounding modes
     *
     * @stability stable
     * @category math
     * @since 3.16.0
     */
    (scale: number): (self: BigDecimal) => BigDecimal;
    /**
     * Computes the floor of a `BigDecimal` at the given scale.
     *
     * **When to use**
     *
     * Use to round a decimal toward negative infinity at a requested scale.
     *
     * **Example** (Rounding decimals down)
     *
     * ```ts import.meta.vitest
     * import { BigDecimal } from "effect"
     *
     * BigDecimal.floor(BigDecimal.fromStringUnsafe("145"), -1) // => BigDecimal.fromBigInt(140n)
     * BigDecimal.floor(BigDecimal.fromStringUnsafe("-14.5")) // => BigDecimal.fromBigInt(-15n)
     * ```
     *
     * @see {@link ceil} for rounding toward positive infinity
     * @see {@link truncate} for rounding toward zero
     * @see {@link round} for configurable rounding modes
     *
     * @stability stable
     * @category math
     * @since 3.16.0
     */
    (self: BigDecimal, scale?: number): BigDecimal;
};
export {};
//# sourceMappingURL=BigDecimal.d.ts.map