@f-o-t/money 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,904 @@
+import { z } from "zod";
+/**
+* Schema for validating ISO 4217 currency codes
+*
+* - Exactly 3 characters
+* - Uppercase letters only
+*/
+declare const CurrencyCodeSchema: z.ZodString;
+/**
+* Schema for Currency definition
+*
+* Used for registering custom currencies.
+*/
+declare const CurrencySchema: z.ZodObject<{
+	code: z.ZodString;
+	numericCode: z.ZodNumber;
+	name: z.ZodString;
+	decimalPlaces: z.ZodNumber;
+	symbol: z.ZodOptional<z.ZodString>;
+	subunitName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+* Currency type inferred from schema
+*/
+type Currency = z.infer<typeof CurrencySchema>;
+/**
+* Schema for validating decimal amount strings
+*
+* Accepts:
+* - Positive numbers: "123.45", "100", "0.5"
+* - Negative numbers: "-123.45", "-100"
+* - Integer strings: "100", "-50"
+*/
+declare const AmountStringSchema: z.ZodString;
+/**
+* Schema for Money JSON representation
+*
+* Used for API requests/responses and JSON serialization.
+*
+* @example
+* { amount: "123.45", currency: "USD" }
+*/
+declare const MoneySchema: z.ZodObject<{
+	amount: z.ZodString;
+	currency: z.ZodString;
+}, z.core.$strip>;
+/**
+* MoneyJSON type - serializable representation of Money
+*/
+type MoneyJSON = z.infer<typeof MoneySchema>;
+/**
+* Schema for database Money storage
+*
+* Identical to MoneySchema but with a distinct type for clarity.
+*/
+declare const DatabaseMoneySchema: z.ZodObject<{
+	amount: z.ZodString;
+	currency: z.ZodString;
+}, z.core.$strip>;
+/**
+* DatabaseMoney type for database storage
+*/
+type DatabaseMoney = z.infer<typeof DatabaseMoneySchema>;
+/**
+* Schema for user input of money amounts
+*
+* More permissive than AmountStringSchema - accepts both strings and numbers.
+*/
+declare const MoneyInputSchema: z.ZodObject<{
+	amount: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+	currency: z.ZodString;
+}, z.core.$strip>;
+/**
+* MoneyInput type for flexible user input
+*/
+type MoneyInput = z.infer<typeof MoneyInputSchema>;
+/**
+* Schema for the internal Money representation
+*
+* Note: This schema is for validation only. The actual Money type uses BigInt
+* which is handled separately since Zod's bigint requires different parsing.
+*/
+declare const MoneyInternalSchema: z.ZodObject<{
+	amount: z.ZodBigInt;
+	currency: z.ZodString;
+	scale: z.ZodNumber;
+}, z.core.$strip>;
+/**
+* Core Money type representing a monetary value with currency
+*
+* @property amount - The amount in minor units (e.g., cents) as a BigInt
+* @property currency - ISO 4217 currency code (e.g., "USD", "BRL", "JPY")
+* @property scale - Number of decimal places for this currency
+*/
+type Money = z.infer<typeof MoneyInternalSchema>;
+/**
+* Schema for money formatting options
+*/
+declare const FormatOptionsSchema: z.ZodObject<{
+	locale: z.ZodOptional<z.ZodString>;
+	notation: z.ZodOptional<z.ZodEnum<{
+		standard: "standard";
+		compact: "compact";
+	}>>;
+	signDisplay: z.ZodOptional<z.ZodEnum<{
+		never: "never";
+		auto: "auto";
+		always: "always";
+		exceptZero: "exceptZero";
+	}>>;
+	currencyDisplay: z.ZodOptional<z.ZodEnum<{
+		symbol: "symbol";
+		code: "code";
+		name: "name";
+		narrowSymbol: "narrowSymbol";
+	}>>;
+	hideSymbol: z.ZodOptional<z.ZodBoolean>;
+	minimumFractionDigits: z.ZodOptional<z.ZodNumber>;
+	maximumFractionDigits: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+* FormatOptions type for formatting configuration
+*/
+type FormatOptions = z.infer<typeof FormatOptionsSchema>;
+/**
+* Schema for allocation ratios
+*
+* - Non-empty array
+* - Non-negative numbers
+* - At least one non-zero value
+*/
+declare const AllocationRatiosSchema: z.ZodArray<z.ZodNumber>;
+/**
+* AllocationRatios type
+*/
+type AllocationRatios = z.infer<typeof AllocationRatiosSchema>;
+/**
+* @deprecated Use Currency instead
+*/
+type CurrencyInput = Currency;
+/**
+* Rounding mode for amount parsing
+*/
+type RoundingMode = "truncate" | "round";
+/**
+* Assert that two Money values have the same currency and scale
+* @throws CurrencyMismatchError if currencies don't match
+* @throws ScaleMismatchError if scales don't match
+*/
+declare function assertSameCurrency(a: Money, b: Money): void;
+/**
+* Assert all Money values in an array have the same currency and scale
+* @throws CurrencyMismatchError if currencies don't match
+* @throws ScaleMismatchError if scales don't match
+*/
+declare function assertAllSameCurrency(moneys: Money[]): void;
+/**
+* Create an immutable Money object
+*
+* @param amount - Amount in minor units as BigInt
+* @param currency - ISO 4217 currency code (uppercase)
+* @param scale - Number of decimal places for this currency
+* @returns Frozen Money object
+*/
+declare function createMoney(amount: bigint, currency: string, scale: number): Money;
+/**
+* Parse a decimal string to minor units
+*
+* @param amountStr - Decimal string (e.g., "123.45", "100", "-50.5")
+* @param scale - Target scale (decimal places)
+* @param roundingMode - How to handle excess decimal places (default: "truncate")
+* @returns Amount in minor units as BigInt
+*/
+declare function parseDecimalToMinorUnits(amountStr: string, scale: number, roundingMode?: RoundingMode): bigint;
+/**
+* Convert minor units to decimal string
+*
+* @param amount - Amount in minor units
+* @param scale - Number of decimal places
+* @returns Decimal string representation
+*/
+declare function minorUnitsToDecimal(amount: bigint, scale: number): string;
+/**
+* Create Money from a decimal amount
+*
+* By default, excess decimal places are TRUNCATED, not rounded.
+* Use roundingMode parameter or ofRounded() for rounding behavior.
+*
+* IMPORTANT: Always pass strings for amounts to avoid floating-point precision issues.
+* Passing numbers like (0.1 + 0.2) will produce incorrect results due to JavaScript
+* floating-point arithmetic limitations.
+*
+* @param amount - Decimal amount as STRING (preferred) or number
+* @param currency - ISO 4217 currency code
+* @param roundingMode - How to handle excess decimal places (default: "truncate")
+* @returns Money instance
+*
+* @example
+* // CORRECT - String amounts are precise
+* of("123.45", "USD")
+* of("0.1", "USD")
+*
+* // AVOID - Number literals work but strings are safer
+* of(123.45, "USD")
+*
+* // WRONG - Computed numbers lose precision
+* of(0.1 + 0.2, "USD")  // Results in 0.30000000000000004
+*/
+declare function of(amount: number | string, currency: string, roundingMode?: RoundingMode): Money;
+/**
+* Create Money from a decimal amount with rounding
+*
+* Convenience function that rounds excess decimal places using banker's rounding.
+* Equivalent to: of(amount, currency, "round")
+*
+* @param amount - Decimal amount as string or number
+* @param currency - ISO 4217 currency code
+* @returns Money instance with rounded amount
+*
+* @example
+* ofRounded("10.999", "USD")  // $11.00
+* ofRounded("10.995", "USD")  // $11.00 (rounds to even)
+* ofRounded("10.994", "USD")  // $10.99
+*/
+declare function ofRounded(amount: number | string, currency: string): Money;
+/**
+* Create Money from minor units (cents, pence, etc.)
+*
+* Use this when you already have the amount in the smallest currency unit.
+*
+* @param minorUnits - Amount in minor units (e.g., cents)
+* @param currency - ISO 4217 currency code
+* @returns Money instance
+*
+* @example
+* fromMinorUnits(12345, "USD")  // $123.45
+* fromMinorUnits(12345n, "USD") // Same, using BigInt
+* fromMinorUnits(100, "JPY")    // ¥100 (no decimal places)
+*/
+declare function fromMinorUnits(minorUnits: number | bigint, currency: string): Money;
+/**
+* Create zero Money for a currency
+*
+* @param currency - ISO 4217 currency code
+* @returns Money instance with zero amount
+*
+* @example
+* zero("USD") // $0.00
+* zero("JPY") // ¥0
+*/
+declare function zero(currency: string): Money;
+/**
+* Create Money from major units (dollars, reais, etc.)
+*
+* Convenience alias for `of` to make intent clearer.
+*
+* @param amount - Amount in major units
+* @param currency - ISO 4217 currency code
+* @returns Money instance
+*/
+declare function fromMajorUnits(amount: number | string, currency: string): Money;
+/**
+* Banker's rounding (round half to even)
+*
+* When the value is exactly halfway between two values, rounds to the nearest even number.
+* This prevents systematic bias that would occur with traditional rounding.
+*
+* Halfway detection: remainder * 2 == divisor (works for both odd and even divisors)
+*
+* Examples:
+* - 25 / 10 = 2.5 → 2 (rounds down to even)
+* - 35 / 10 = 3.5 → 4 (rounds up to even)
+* - 24 / 10 = 2.4 → 2 (normal round down)
+* - 26 / 10 = 2.6 → 3 (normal round up)
+* - 21 / 6  = 3.5 → 4 (halfway, round to even)
+* - 15 / 7  = 2.14... → 2 (not halfway, round down)
+*
+* @param value - The value to round (numerator)
+* @param divisor - The divisor to round by
+* @returns Rounded quotient
+*/
+declare function bankersRound(value: bigint, divisor: bigint): bigint;
+/**
+* Extended precision for intermediate calculations
+* Using 18 decimal places to handle even ETH-level precision
+*/
+declare const EXTENDED_PRECISION = 18;
+/**
+* Scale factor for extended precision calculations
+*/
+declare const PRECISION_FACTOR: bigint;
+/**
+* ISO 4217 currency definitions
+*
+* Includes:
+* - Major world currencies (USD, EUR, GBP, etc.)
+* - Zero decimal currencies (JPY, KRW, VND)
+* - Three decimal currencies (KWD, BHD, OMR)
+* - Popular cryptocurrencies (BTC, ETH)
+*/
+declare const ISO_4217_CURRENCIES: Record<string, Currency>;
+/**
+* Get a currency by its code
+*
+* @param code - ISO 4217 currency code (case-insensitive)
+* @returns Currency definition
+* @throws UnknownCurrencyError if currency is not found
+*/
+declare function getCurrency(code: string): Currency;
+/**
+* Register a custom currency
+*
+* Can be used to add new currencies or override existing ones.
+*
+* @param currency - Currency definition to register
+*/
+declare function registerCurrency(currency: Currency): void;
+/**
+* Check if a currency code is registered
+*
+* @param code - ISO 4217 currency code (case-insensitive)
+* @returns true if currency exists
+*/
+declare function hasCurrency(code: string): boolean;
+/**
+* Get all registered currencies (both ISO and custom)
+*
+* @returns Record of all currencies keyed by code
+*/
+declare function getAllCurrencies(): Record<string, Currency>;
+/**
+* Clear all custom currencies (useful for testing)
+*/
+declare function clearCustomCurrencies(): void;
+/**
+* Base error class for all money-related errors
+*/
+declare class MoneyError extends Error {
+	constructor(message: string);
+}
+/**
+* Error thrown when attempting operations on different currencies
+*/
+declare class CurrencyMismatchError extends MoneyError {
+	readonly currencyA: string;
+	readonly currencyB: string;
+	constructor(message: string, currencyA: string, currencyB: string);
+	static create(currencyA: string, currencyB: string): CurrencyMismatchError;
+}
+/**
+* Error thrown when an invalid amount is provided
+*/
+declare class InvalidAmountError extends MoneyError {
+	constructor(message: string);
+}
+/**
+* Error thrown when attempting to divide by zero
+*/
+declare class DivisionByZeroError extends MoneyError {
+	constructor(message?: string);
+}
+/**
+* Error thrown when a currency code is not found in the registry
+*/
+declare class UnknownCurrencyError extends MoneyError {
+	readonly currencyCode?: string | undefined;
+	constructor(message: string, currencyCode?: string | undefined);
+}
+/**
+* Error thrown when a value exceeds safe integer range
+*/
+declare class OverflowError extends MoneyError {
+	constructor(message?: string);
+}
+/**
+* Error thrown when Money values have inconsistent scales for the same currency
+*/
+declare class ScaleMismatchError extends MoneyError {
+	readonly currency: string;
+	readonly scaleA: number;
+	readonly scaleB: number;
+	constructor(message: string, currency: string, scaleA: number, scaleB: number);
+	static create(currency: string, scaleA: number, scaleB: number): ScaleMismatchError;
+}
+/**
+* Format Money as a localized currency string
+*
+* Uses Intl.NumberFormat for locale-aware formatting.
+*
+* @param money - Money value to format
+* @param locale - Locale for formatting (e.g., "en-US", "pt-BR")
+* @param options - Formatting options
+* @returns Formatted currency string
+*
+* @example
+* format(of("1234.56", "USD"), "en-US")           // "$1,234.56"
+* format(of("1234.56", "BRL"), "pt-BR")           // "R$ 1.234,56"
+* format(of("1234", "JPY"), "ja-JP")              // "¥1,234"
+* format(of("1234567.89", "USD"), "en-US", { notation: "compact" }) // "$1.2M"
+*/
+declare function format(money: Money, locale?: string, options?: FormatOptions): string;
+/**
+* Format Money as a compact string (e.g., 1.2K, 3.4M)
+*
+* @param money - Money value to format
+* @param locale - Locale for formatting
+* @returns Compact formatted string
+*
+* @example
+* formatCompact(of("1234567.89", "USD"), "en-US") // "$1.2M"
+* formatCompact(of("1234.56", "BRL"), "pt-BR")    // "R$ 1,23 mil"
+*/
+declare function formatCompact(money: Money, locale?: string): string;
+/**
+* Convert Money to decimal string representation
+*
+* Always includes the appropriate number of decimal places.
+* Useful for JSON serialization or display without locale formatting.
+*
+* @param money - Money value
+* @returns Decimal string (e.g., "123.45", "-50.00", "100")
+*
+* @example
+* toDecimal(of("123.45", "USD"))  // "123.45"
+* toDecimal(of("-50", "USD"))     // "-50.00"
+* toDecimal(of("100", "JPY"))     // "100"
+*/
+declare function toDecimal(money: Money): string;
+/**
+* Format Money without currency symbol
+*
+* @param money - Money value
+* @param locale - Locale for number formatting
+* @returns Formatted number without currency symbol
+*
+* @example
+* formatAmount(of("1234.56", "USD"), "en-US")  // "1,234.56"
+* formatAmount(of("1234.56", "BRL"), "pt-BR")  // "1.234,56"
+*/
+declare function formatAmount(money: Money, locale?: string): string;
+/**
+* Parse a formatted currency string into Money
+*
+* Handles locale-specific formatting including:
+* - Different decimal separators (. or ,)
+* - Different grouping separators (, or . or space)
+* - Currency symbols and codes
+* - Negative amounts in various formats
+*
+* @param formatted - Formatted currency string (e.g., "R$ 1.234,56", "$1,234.56")
+* @param locale - Locale used for formatting (e.g., "pt-BR", "en-US")
+* @param currency - ISO 4217 currency code
+* @returns Money instance
+*
+* @example
+* parse("R$ 1.234,56", "pt-BR", "BRL")  // 1234.56 BRL
+* parse("$1,234.56", "en-US", "USD")    // 1234.56 USD
+* parse("(€1.234,56)", "de-DE", "EUR")  // -1234.56 EUR
+* parse("-¥1,234", "ja-JP", "JPY")      // -1234 JPY
+*/
+declare function parse(formatted: string, locale: string, currency: string): Money;
+/**
+* Sum an array of Money values
+*
+* @param moneys - Array of Money values (must all be same currency)
+* @returns Sum of all values
+* @throws CurrencyMismatchError if currencies don't match
+* @throws InvalidAmountError if array is empty
+*
+* @example
+* sum([of("10.00", "USD"), of("20.00", "USD"), of("30.00", "USD")]) // $60.00
+*/
+declare function sum(moneys: Money[]): Money;
+/**
+* Sum an array of Money values, returning zero if empty
+*
+* @param moneys - Array of Money values
+* @param currency - Currency to use for zero if array is empty
+* @returns Sum of all values, or zero of the specified currency
+*
+* @example
+* sumOrZero([of("10.00", "USD")], "USD")  // $10.00
+* sumOrZero([], "USD")                     // $0.00
+*/
+declare function sumOrZero(moneys: Money[], currency: string): Money;
+/**
+* Find the minimum Money value
+*
+* @param moneys - Array of Money values (must all be same currency)
+* @returns Minimum value
+* @throws CurrencyMismatchError if currencies don't match
+* @throws InvalidAmountError if array is empty
+*
+* @example
+* min([of("10.00", "USD"), of("5.00", "USD"), of("20.00", "USD")]) // $5.00
+*/
+declare function min(moneys: Money[]): Money;
+/**
+* Find the maximum Money value
+*
+* @param moneys - Array of Money values (must all be same currency)
+* @returns Maximum value
+* @throws CurrencyMismatchError if currencies don't match
+* @throws InvalidAmountError if array is empty
+*
+* @example
+* max([of("10.00", "USD"), of("5.00", "USD"), of("20.00", "USD")]) // $20.00
+*/
+declare function max(moneys: Money[]): Money;
+/**
+* Calculate the average of Money values
+*
+* Uses banker's rounding for the result.
+*
+* @param moneys - Array of Money values (must all be same currency)
+* @returns Average value with banker's rounding
+* @throws CurrencyMismatchError if currencies don't match
+* @throws InvalidAmountError if array is empty
+*
+* @example
+* average([of("10.00", "USD"), of("20.00", "USD"), of("30.00", "USD")]) // $20.00
+* average([of("10.00", "USD"), of("10.00", "USD"), of("10.00", "USD")]) // $10.00
+* average([of("1.00", "USD"), of("2.00", "USD")])                        // $1.50
+*/
+declare function average(moneys: Money[]): Money;
+/**
+* Calculate median of Money values
+*
+* For even-length arrays, returns the average of the two middle values.
+*
+* @param moneys - Array of Money values (must all be same currency)
+* @returns Median value
+* @throws CurrencyMismatchError if currencies don't match
+* @throws InvalidAmountError if array is empty
+*
+* @example
+* median([of("1.00", "USD"), of("2.00", "USD"), of("3.00", "USD")]) // $2.00
+* median([of("1.00", "USD"), of("2.00", "USD"), of("3.00", "USD"), of("4.00", "USD")]) // $2.50
+*/
+declare function median(moneys: Money[]): Money;
+/**
+* Allocate Money according to ratios using the Largest Remainder Method
+*
+* This algorithm distributes money while guaranteeing that:
+* 1. sum(allocated) === original (no cents are lost or gained)
+* 2. Allocation is fair (remainders are distributed to largest fractional parts)
+* 3. Result is deterministic (same input always produces same output)
+*
+* Algorithm:
+* 1. Calculate each allocation's ideal fractional share
+* 2. Round down to get initial integer amounts
+* 3. Calculate remainders (fractional parts lost)
+* 4. Sort by remainder descending
+* 5. Distribute remaining cents one by one, starting with largest remainders
+*
+* @param money - Money to allocate
+* @param ratios - Proportions to allocate (e.g., [60, 25, 15] or [1, 1, 1])
+* @returns Array of Money values that sum to the original
+* @throws InvalidAmountError if ratios are invalid
+*
+* @example
+* allocate(of("100.00", "USD"), [60, 25, 15])  // [$60.00, $25.00, $15.00]
+* allocate(of("100.00", "USD"), [1, 1, 1])     // [$33.34, $33.33, $33.33]
+* allocate(of("10.00", "USD"), [1, 1, 1])      // [$3.34, $3.33, $3.33]
+* allocate(of("7", "JPY"), [1, 1, 1])          // [¥3, ¥2, ¥2]
+*/
+declare function allocate(money: Money, ratios: number[]): Money[];
+/**
+* Split Money equally among n recipients
+*
+* @param money - Money to split
+* @param count - Number of equal parts
+* @returns Array of Money values
+*
+* @example
+* split(of("100.00", "USD"), 3)  // [$33.34, $33.33, $33.33]
+* split(of("10.00", "USD"), 4)   // [$2.50, $2.50, $2.50, $2.50]
+*/
+declare function split(money: Money, count: number): Money[];
+/**
+* Add two Money values
+*
+* @param a - First Money value
+* @param b - Second Money value (must be same currency)
+* @returns Sum of a and b
+* @throws CurrencyMismatchError if currencies don't match
+*
+* @example
+* add(of("10.50", "USD"), of("5.25", "USD")) // $15.75
+*/
+declare function add(a: Money, b: Money): Money;
+/**
+* Subtract one Money value from another
+*
+* @param a - Money value to subtract from
+* @param b - Money value to subtract (must be same currency)
+* @returns Difference of a - b
+* @throws CurrencyMismatchError if currencies don't match
+*
+* @example
+* subtract(of("10.50", "USD"), of("5.25", "USD")) // $5.25
+*/
+declare function subtract(a: Money, b: Money): Money;
+/**
+* Multiply Money by a factor
+*
+* Uses banker's rounding for the final result.
+*
+* @param money - Money value to multiply
+* @param factor - Multiplication factor (number or string for precision)
+* @returns Product with banker's rounding applied
+*
+* @example
+* multiply(of("10.00", "USD"), 1.5)    // $15.00
+* multiply(of("10.00", "USD"), "1.5")  // $15.00 (string for precision)
+* multiply(of("33.33", "USD"), 3)      // $99.99
+*/
+declare function multiply(money: Money, factor: number | string): Money;
+/**
+* Divide Money by a divisor
+*
+* Uses banker's rounding for the final result.
+*
+* @param money - Money value to divide
+* @param divisor - Division factor (number or string for precision)
+* @returns Quotient with banker's rounding applied
+* @throws DivisionByZeroError if divisor is zero
+*
+* @example
+* divide(of("10.00", "USD"), 3)    // $3.33 (banker's rounding)
+* divide(of("100.00", "USD"), 4)   // $25.00
+*/
+declare function divide(money: Money, divisor: number | string): Money;
+/**
+* Calculate a percentage of Money
+*
+* @param money - Money value
+* @param percent - Percentage (e.g., 15 for 15%)
+* @returns Percentage amount with banker's rounding
+*
+* @example
+* percentage(of("100.00", "USD"), 15)   // $15.00
+* percentage(of("200.00", "USD"), 7.5)  // $15.00
+*/
+declare function percentage(money: Money, percent: number): Money;
+/**
+* Negate a Money value
+*
+* @param money - Money value to negate
+* @returns Money with opposite sign
+*
+* @example
+* negate(of("10.00", "USD"))   // -$10.00
+* negate(of("-5.00", "USD"))   // $5.00
+*/
+declare function negate(money: Money): Money;
+/**
+* Get absolute value of Money
+*
+* @param money - Money value
+* @returns Money with positive amount
+*
+* @example
+* absolute(of("-10.00", "USD"))  // $10.00
+* absolute(of("10.00", "USD"))   // $10.00
+*/
+declare function absolute(money: Money): Money;
+/**
+* Money equals operator
+*/
+declare const moneyEqualsOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_eq", unknown, unknown>;
+/**
+* Money not equals operator
+*/
+declare const moneyNotEqualsOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_neq", unknown, unknown>;
+/**
+* Money greater than operator
+*/
+declare const moneyGreaterThanOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_gt", unknown, unknown>;
+/**
+* Money greater than or equal operator
+*/
+declare const moneyGreaterThanOrEqualOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_gte", unknown, unknown>;
+/**
+* Money less than operator
+*/
+declare const moneyLessThanOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_lt", unknown, unknown>;
+/**
+* Money less than or equal operator
+*/
+declare const moneyLessThanOrEqualOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_lte", unknown, unknown>;
+/**
+* Money between operator (inclusive)
+*/
+declare const moneyBetweenOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_between", unknown, unknown>;
+/**
+* Money is positive operator
+*/
+declare const moneyPositiveOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_positive", unknown, unknown>;
+/**
+* Money is negative operator
+*/
+declare const moneyNegativeOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_negative", unknown, unknown>;
+/**
+* Money is zero operator
+*/
+declare const moneyZeroOperator: import("@f-o-t/condition-evaluator").CustomOperatorConfig<"money_zero", unknown, unknown>;
+/**
+* Check if two Money values are equal
+*
+* @example
+* equals(of("10.00", "USD"), of("10.00", "USD")) // true
+*/
+declare function equals(a: Money, b: Money): boolean;
+/**
+* Check if first Money is greater than second
+*
+* @example
+* greaterThan(of("20.00", "USD"), of("10.00", "USD")) // true
+*/
+declare function greaterThan(a: Money, b: Money): boolean;
+/**
+* Check if first Money is greater than or equal to second
+*/
+declare function greaterThanOrEqual(a: Money, b: Money): boolean;
+/**
+* Check if first Money is less than second
+*
+* @example
+* lessThan(of("10.00", "USD"), of("20.00", "USD")) // true
+*/
+declare function lessThan(a: Money, b: Money): boolean;
+/**
+* Check if first Money is less than or equal to second
+*/
+declare function lessThanOrEqual(a: Money, b: Money): boolean;
+/**
+* Check if Money is positive (amount > 0)
+*
+* @example
+* isPositive(of("10.00", "USD")) // true
+* isPositive(of("-10.00", "USD")) // false
+*/
+declare function isPositive(money: Money): boolean;
+/**
+* Check if Money is negative (amount < 0)
+*
+* @example
+* isNegative(of("-10.00", "USD")) // true
+* isNegative(of("10.00", "USD")) // false
+*/
+declare function isNegative(money: Money): boolean;
+/**
+* Check if Money is zero (amount === 0)
+*
+* @example
+* isZero(of("0.00", "USD")) // true
+*/
+declare function isZero(money: Money): boolean;
+/**
+* Compare two Money values
+* @returns -1 if a < b, 0 if a === b, 1 if a > b
+*
+* @example
+* compare(of("10.00", "USD"), of("20.00", "USD")) // -1
+* compare(of("20.00", "USD"), of("10.00", "USD")) // 1
+* compare(of("10.00", "USD"), of("10.00", "USD")) // 0
+*/
+declare function compare(a: Money, b: Money): -1 | 0 | 1;
+/**
+* Convert Money to minor units as a number
+*
+* Use this when you need to store the amount in a database column
+* that doesn't support BigInt, or when interfacing with APIs that
+* expect number types.
+*
+* @param money - Money value
+* @returns Amount in minor units (cents) as a number
+* @throws OverflowError if the value exceeds Number.MAX_SAFE_INTEGER
+*
+* @example
+* toMinorUnits(of("123.45", "USD"))  // 12345
+* toMinorUnits(of("100", "JPY"))     // 100
+*/
+declare function toMinorUnits(money: Money): number;
+/**
+* Convert Money to minor units as a BigInt
+*
+* Use this when you need the raw BigInt value without any conversion.
+*
+* @param money - Money value
+* @returns Amount in minor units (cents) as BigInt
+*
+* @example
+* toMinorUnitsBigInt(of("123.45", "USD"))  // 12345n
+*/
+declare function toMinorUnitsBigInt(money: Money): bigint;
+/**
+* Convert Money to major units as a number
+*
+* @deprecated Use toMajorUnitsString() for precision-safe conversion.
+* This function may lose precision for large amounts.
+*
+* @param money - Money value
+* @returns Amount in major units (dollars, reais, etc.) as a number
+*
+* @example
+* toMajorUnits(of("123.45", "USD"))  // 123.45
+* toMajorUnits(of("100", "JPY"))     // 100
+*/
+declare function toMajorUnits(money: Money): number;
+/**
+* Convert Money to major units as a string (precision-safe)
+*
+* Use this for precise decimal representation without precision loss.
+*
+* @param money - Money value
+* @returns Amount in major units as a string (e.g., "123.45")
+*
+* @example
+* toMajorUnitsString(of("123.45", "USD"))  // "123.45"
+* toMajorUnitsString(of("999999999999999.99", "USD"))  // "999999999999999.99"
+*/
+declare function toMajorUnitsString(money: Money): string;
+/**
+* Convert Money to a string of minor units
+*
+* Useful for database storage or APIs that accept string representations.
+*
+* @param money - Money value
+* @returns Amount in minor units as a string
+*
+* @example
+* toMinorUnitsString(of("123.45", "USD"))  // "12345"
+*/
+declare function toMinorUnitsString(money: Money): string;
+/**
+* Convert Money to JSON representation
+*
+* Stores amount as a decimal string to preserve precision.
+*
+* @param money - Money value
+* @returns JSON-serializable object
+*
+* @example
+* toJSON(of("123.45", "USD"))
+* // { amount: "123.45", currency: "USD" }
+*/
+declare function toJSON(money: Money): MoneyJSON;
+/**
+* Create Money from JSON representation
+*
+* @param json - JSON object with amount and currency
+* @returns Money instance
+*
+* @example
+* fromJSON({ amount: "123.45", currency: "USD" })
+* // Money with $123.45
+*/
+declare function fromJSON(json: MoneyJSON): Money;
+/**
+* Convert Money to database-friendly format
+*
+* Stores amount as a string to preserve precision in databases
+* that don't support BigInt natively.
+*
+* @param money - Money value
+* @returns Database-friendly object
+*
+* @example
+* toDatabase(of("123.45", "USD"))
+* // { amount: "123.45", currency: "USD" }
+*/
+declare function toDatabase(money: Money): DatabaseMoney;
+/**
+* Create Money from database format
+*
+* @param data - Database object with amount and currency
+* @returns Money instance
+*/
+declare function fromDatabase(data: DatabaseMoney): Money;
+/**
+* Serialize Money to a compact string format
+*
+* Format: "AMOUNT CURRENCY" (e.g., "123.45 USD")
+*
+* @param money - Money value
+* @returns Compact string representation
+*
+* @example
+* serialize(of("123.45", "USD"))  // "123.45 USD"
+*/
+declare function serialize(money: Money): string;
+/**
+* Deserialize Money from compact string format
+*
+* @param str - String in format "AMOUNT CURRENCY"
+* @returns Money instance
+*
+* @example
+* deserialize("123.45 USD")  // Money with $123.45
+*/
+declare function deserialize(str: string): Money;
+export { zero, toMinorUnitsString, toMinorUnitsBigInt, toMinorUnits, toMajorUnitsString, toMajorUnits, toJSON, toDecimal, toDatabase, sumOrZero, sum, subtract, split, serialize, registerCurrency, percentage, parseDecimalToMinorUnits, parse, ofRounded, of, negate, multiply, moneyZeroOperator, moneyPositiveOperator, moneyNotEqualsOperator, moneyNegativeOperator, moneyLessThanOrEqualOperator, moneyLessThanOperator, moneyGreaterThanOrEqualOperator, moneyGreaterThanOperator, moneyEqualsOperator, moneyBetweenOperator, minorUnitsToDecimal, min, median, max, lessThanOrEqual, lessThan, isZero, isPositive, isNegative, hasCurrency, greaterThanOrEqual, greaterThan, getCurrency, getAllCurrencies, fromMinorUnits, fromMajorUnits, fromJSON, fromDatabase, formatCompact, formatAmount, format, equals, divide, deserialize, createMoney, compare, clearCustomCurrencies, bankersRound, average, assertSameCurrency, assertAllSameCurrency, allocate, add, absolute, UnknownCurrencyError, ScaleMismatchError, RoundingMode, PRECISION_FACTOR, OverflowError, MoneySchema, MoneyJSON, MoneyInternalSchema, MoneyInputSchema, MoneyInput, MoneyError, Money, InvalidAmountError, ISO_4217_CURRENCIES, FormatOptionsSchema, FormatOptions, EXTENDED_PRECISION, DivisionByZeroError, DatabaseMoneySchema, DatabaseMoney, CurrencySchema, CurrencyMismatchError, CurrencyInput, CurrencyCodeSchema, Currency, AmountStringSchema, AllocationRatiosSchema, AllocationRatios };