@temboplus/frontend-core 0.2.20-beta.2 → 0.2.21

package/dist/models/amount/amount.d.ts

@@ -1,761 +0,0 @@
-import { z } from "zod";
-import { CurrencyCode } from "../currency/index.js";
-/**
- * Regular expression for validating amount strings
- * Supports both positive and negative amounts with optional comma separators and decimals
- */
-declare const AMOUNT_REGEX: RegExp;
-/**
- * Zod schema for Amount JSON serialization
- * This schema validates the JSON representation of an Amount instance
- */
-export declare const AmountJSONSchema: z.ZodObject<{
-    /** The numeric value of the amount (can be positive, negative, or zero) */
-    value: z.ZodNumber;
-    /** The formatted text representation of the amount */
-    text: z.ZodString;
-    /** The ISO currency code */
-    currencyCode: z.ZodString;
-    /** Version for future compatibility */
-    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
-}, "strip", z.ZodTypeAny, {
-    version: string;
-    value: number;
-    text: string;
-    currencyCode: string;
-}, {
-    value: number;
-    text: string;
-    currencyCode: string;
-    version?: string | undefined;
-}>;
-/**
- * Infer the AmountJSON type from the schema
- */
-export type AmountJSON = z.infer<typeof AmountJSONSchema>;
-/**
- * Represents a monetary amount with currency information
- *
- * Enhanced with currency-amount parsing support:
- * - Supports formats like "TZS1000", "1000TZS", "TZS1,000.00", "1,000.00TZS"
- * - Case-insensitive currency codes
- * - US/UK format (comma for thousands, period for decimal)
- * - Automatic whitespace removal
- * - Clear error messages for invalid formats
- *
- * @example
- * ```typescript
- * // Currency-amount combinations
- * Amount.from('TZS10000');           // TSh 10,000.00
- * Amount.from('TZS 10,000');         // TSh 10,000.00 (spaces removed)
- * Amount.from('10000TZS');           // TSh 10,000.00
- * Amount.from('TZS1,234.56');        // TSh 1,234.56
- * Amount.from('-TZS1000');           // -TSh 1,000.00
- * Amount.from('TZS-1000');           // -TSh 1,000.00
- *
- * // Traditional usage still works
- * Amount.from(1000, 'TZS');          // TSh 1,000.00
- * Amount.from('1000', 'USD');        // $1,000.00
- * ```
- */
-/**
- * JSON representation interface for Amount serialization
- */
-export interface AmountJson {
-    /** The numeric value of the amount (can be positive, negative, or zero) */
-    value: number;
-    /** The formatted text representation of the amount */
-    text: string;
-    /** The ISO currency code */
-    currencyCode: string;
-    /** Version for future compatibility */
-    version?: string;
-}
-/**
- * Formatting options for the enhanced format method
- */
-interface AmountFormatOptions {
-    /** Include currency symbol (e.g., $, TSh) */
-    includeSymbol?: boolean;
-    /** Include currency code (e.g., USD, TZS) */
-    includeCurrency?: boolean;
-    /** Position of currency symbol */
-    symbolPosition?: "before" | "after";
-    /** Use thousands separators (commas) */
-    useGrouping?: boolean;
-    /** Minimum number of decimal places */
-    minimumFractionDigits?: number;
-    /** Maximum number of decimal places */
-    maximumFractionDigits?: number;
-    /** How to display sign for positive/negative numbers */
-    showSign?: "always" | "negative" | "never";
-    /** Locale for formatting (defaults to 'en-US') */
-    locale?: string;
-    /** Custom thousands separator */
-    thousandsSeparator?: string;
-    /** Custom decimal separator */
-    decimalSeparator?: string;
-    /** Use native formatting with Intl.NumberFormat (defaults to false for backward compatibility) */
-    useNativeFormatting?: boolean;
-    /** Use native currency symbol instead of international symbol */
-    useNativeSymbol?: boolean;
-    /** Prefer native locale for the currency (overrides provided locale) */
-    useNativeLocale?: boolean;
-}
-/**
- * Represents a monetary amount with currency information
- *
- * Features:
- * - Supports both positive and negative amounts
- * - Handles multiple input formats (strings with commas, numbers, etc.)
- * - Provides mathematical operations (add, subtract, multiply, divide)
- * - Includes comparison operations (equals, greaterThan, etc.)
- * - Maintains currency consistency across operations
- * - Immutable - all operations return new Amount instances
- *
- * @example
- * ```typescript
- * // Creating amounts
- * const positive = Amount.from(1000, 'USD'); // $1,000.00
- * const negative = Amount.from(-500, 'USD');  // -$500.00
- * const fromString = Amount.from('-1,234.56', 'EUR'); // -€1,234.56
- *
- * // Mathematical operations
- * const sum = positive.add(negative); // $500.00
- * const product = positive.multiply(-0.1); // -$100.00
- *
- * // Comparisons
- * const isNegative = negative.isNegative(); // true
- * const isPositive = positive.isPositive(); // true
- * ```
- */
-declare class Amount {
-    private readonly value;
-    private readonly text;
-    private readonly currency;
-    /**
-     * Private constructor to ensure proper validation through factory methods
-     *
-     * @param value - The numeric value of the amount (can be positive or negative)
-     * @param text - The formatted text representation of the amount
-     * @param currencyCode - The currency code for this amount
-     * @throws {Error} When currency code is invalid
-     * @private
-     */
-    private constructor();
-    /**
-     * Creates an Amount instance from string or number input
-     *
-     * Supports currency-amount combinations like:
-     * - "TZS10000", "10000TZS" (no space)
-     * - "TZS 10,000", "10,000 TZS" (with spaces - automatically cleaned)
-     * - "-TZS1000", "TZS-1000", "-1000TZS" (negative amounts)
-     * - Case-insensitive: "tzs10000", "TZS10000", "Tzs10000"
-     *
-     * @param input - String with currency-amount or number
-     * @param currencyCode - Currency code (optional if detected from string)
-     * @returns Amount instance or undefined if invalid
-     * @throws Error with clear message if format is invalid
-     */
-    static from(input: string | number, currencyCode?: CurrencyCode | null): Amount | undefined;
-    /**
-     * Parse currency-amount combination from cleaned string
-     * @param cleaned - String with whitespace already removed
-     * @returns Object with currency code and amount string
-     */
-    private static parseCurrencyAmount;
-    /**
-     * Validate and normalize currency code
-     * @param code - Currency code string (e.g., "TZS", "tzs")
-     * @returns Normalized currency code or undefined if invalid
-     */
-    private static validateCurrencyCode;
-    /**
-     * Create Amount from numeric value
-     */
-    private static fromNumericValue;
-    /**
-     * Create Amount from parsed currency and amount values
-     * @param amountStr - Numeric amount string (may include commas, decimal, minus)
-     * @param currencyCode - Validated currency code
-     */
-    private static fromParsedValues;
-    /**
-     * Returns the currency code
-     *
-     * @returns The ISO currency code (e.g., 'USD', 'EUR', 'TZS')
-     */
-    get currencyCode(): CurrencyCode;
-    /**
-     * Returns the numeric value of the amount
-     *
-     * Can be positive, negative, or zero
-     *
-     * @returns The raw numeric value
-     *
-     * @example
-     * ```typescript
-     * Amount.from(1000).numericValue;    // 1000
-     * Amount.from(-500).numericValue;    // -500
-     * Amount.from(0).numericValue;       // 0
-     * ```
-     */
-    get numericValue(): number;
-    /**
-     * Returns the formatted numeric value of the amount
-     *
-     * Always shows 2 decimal places for consistency, handles negative numbers
-     *
-     * @returns Formatted numeric string
-     *
-     * @example
-     * ```typescript
-     * Amount.from(1234.5).formattedNumericValue;   // "1,234.50"
-     * Amount.from(-1234.5).formattedNumericValue;  // "-1,234.50"
-     * ```
-     */
-    get formattedNumericValue(): string;
-    /**
-     * Adds this amount to another amount or number
-     *
-     * Supports mixing positive and negative amounts:
-     * - Positive + Positive = Positive
-     * - Positive + Negative = Difference
-     * - Negative + Negative = More negative
-     *
-     * @param other - Amount object or number to add
-     * @returns New Amount object with the sum
-     * @throws {Error} If currencies don't match when adding Amount objects
-     *
-     * @example
-     * ```typescript
-     * Amount.from(100).add(Amount.from(-50));  // Amount(50)
-     * Amount.from(-100).add(-50);              // Amount(-150)
-     * Amount.from(100).add(Amount.from(-200)); // Amount(-100)
-     * ```
-     */
-    add(other: Amount | number): Amount;
-    /**
-     * Subtracts another amount or number from this amount
-     *
-     * Supports all combinations of positive and negative amounts:
-     * - Positive - Positive = Difference (can be negative)
-     * - Positive - Negative = Sum (double positive)
-     * - Negative - Positive = More negative
-     * - Negative - Negative = Difference
-     *
-     * @param other - Amount object or number to subtract
-     * @returns New Amount object with the difference
-     * @throws {Error} If currencies don't match when subtracting Amount objects
-     *
-     * @example
-     * ```typescript
-     * Amount.from(100).subtract(Amount.from(150)); // Amount(-50)
-     * Amount.from(100).subtract(Amount.from(-50)); // Amount(150)
-     * Amount.from(-100).subtract(Amount.from(50)); // Amount(-150)
-     * ```
-     */
-    subtract(other: Amount | number): Amount;
-    /**
-     * Multiplies this amount by a number
-     * @param multiplier - Number to multiply by
-     * @returns New Amount object with the product
-     */
-    multiply(multiplier: number): Amount;
-    /**
-     * Divides this amount by a number
-     * @param divisor - Number to divide by
-     * @returns New Amount object with the quotient
-     * @throws Error if divisor is zero
-     */
-    divide(divisor: number): Amount;
-    /**
-     * Returns the absolute value of this amount
-     * @returns New Amount object with absolute value
-     */
-    abs(): Amount;
-    /**
-     * Rounds this amount to the specified number of decimal places
-     *
-     * Works correctly with both positive and negative amounts
-     *
-     * @param decimals - Number of decimal places (defaults to currency's decimal digits)
-     * @returns New Amount object with rounded value
-     *
-     * @example
-     * ```typescript
-     * Amount.from(123.456, 'USD').round();    // Amount(123.46)
-     * Amount.from(-123.456, 'USD').round(1);  // Amount(-123.5)
-     * Amount.from(123.456, 'TZS').round(0);   // Amount(123)
-     * ```
-     */
-    round(decimals?: number): Amount;
-    /**
-     * Returns the minimum of this amount and another amount/number
-     *
-     * Properly handles negative number comparisons
-     *
-     * @param other - Amount object or number to compare with
-     * @returns New Amount object with the minimum value
-     *
-     * @example
-     * ```typescript
-     * Amount.from(100).min(Amount.from(-50));  // Amount(-50)
-     * Amount.from(-100).min(-150);             // Amount(-150)
-     * ```
-     */
-    min(other: Amount | number): Amount;
-    /**
-     * Returns the maximum of this amount and another amount/number
-     *
-     * Properly handles negative number comparisons
-     *
-     * @param other - Amount object or number to compare with
-     * @returns New Amount object with the maximum value
-     *
-     * @example
-     * ```typescript
-     * Amount.from(100).max(Amount.from(-50));  // Amount(100)
-     * Amount.from(-100).max(-50);              // Amount(-50)
-     * ```
-     */
-    max(other: Amount | number): Amount;
-    /**
-     * Checks if this amount equals another amount or number
-     *
-     * Uses strict equality, works with negative numbers
-     *
-     * @param other - Amount object or number to compare with
-     * @returns True if values are equal
-     *
-     * @example
-     * ```typescript
-     * Amount.from(-100).equals(Amount.from(-100)); // true
-     * Amount.from(-100).equals(-100);              // true
-     * Amount.from(-100).equals(100);               // false
-     * ```
-     */
-    equals(other: Amount | number): boolean;
-    /**
-     * Checks if this amount is greater than another amount or number
-     *
-     * Properly handles negative number comparisons (-50 > -100 is true)
-     *
-     * @param other - Amount object or number to compare with
-     * @returns True if this amount is greater
-     *
-     * @example
-     * ```typescript
-     * Amount.from(-50).greaterThan(Amount.from(-100)); // true
-     * Amount.from(-100).greaterThan(-50);              // false
-     * Amount.from(100).greaterThan(-100);              // true
-     * ```
-     */
-    greaterThan(other: Amount | number): boolean;
-    /**
-     * Checks if this amount is less than another amount or number
-     *
-     * Properly handles negative number comparisons (-100 < -50 is true)
-     *
-     * @param other - Amount object or number to compare with
-     * @returns True if this amount is less
-     *
-     * @example
-     * ```typescript
-     * Amount.from(-100).lessThan(Amount.from(-50)); // true
-     * Amount.from(-50).lessThan(-100);              // false
-     * Amount.from(-100).lessThan(100);              // true
-     * ```
-     */
-    lessThan(other: Amount | number): boolean;
-    /**
-     * Checks if this amount is greater than or equal to another amount or number
-     *
-     * @param other - Amount object or number to compare with
-     * @returns True if this amount is greater than or equal
-     */
-    greaterThanOrEqual(other: Amount | number): boolean;
-    /**
-     * Checks if this amount is less than or equal to another amount or number
-     *
-     * @param other - Amount object or number to compare with
-     * @returns True if this amount is less than or equal
-     */
-    lessThanOrEqual(other: Amount | number): boolean;
-    /**
-     * Converts this amount to a different currency
-     *
-     * Works with both positive and negative amounts
-     *
-     * @param targetCurrency - Target currency code
-     * @param exchangeRate - Exchange rate from current currency to target currency
-     * @returns New Amount object in target currency
-     *
-     * @example
-     * ```typescript
-     * Amount.from(-1000, 'TZS').convertTo('USD', 0.00043); // Amount(-0.43, 'USD')
-     * ```
-     */
-    convertTo(targetCurrency: CurrencyCode, exchangeRate: number): Amount;
-    /**
-     * Returns a percentage of this amount
-     *
-     * Maintains the sign of the original amount
-     *
-     * @param percentage - Percentage as a number (e.g., 10 for 10%, -5 for -5%)
-     * @returns New Amount object representing the percentage
-     *
-     * @example
-     * ```typescript
-     * Amount.from(1000).percentage(10);   // Amount(100)
-     * Amount.from(-1000).percentage(10);  // Amount(-100)
-     * Amount.from(1000).percentage(-10);  // Amount(-100)
-     * ```
-     */
-    percentage(percentage: number): Amount;
-    /**
-     * Checks if this amount is zero
-     *
-     * @returns True if the amount is exactly zero
-     *
-     * @example
-     * ```typescript
-     * Amount.from(0).isZero();     // true
-     * Amount.from(-0).isZero();    // true
-     * Amount.from(0.01).isZero();  // false
-     * ```
-     */
-    isZero(): boolean;
-    /**
-     * Checks if this amount is positive
-     *
-     * @returns True if the amount is greater than zero
-     *
-     * @example
-     * ```typescript
-     * Amount.from(100).isPositive();  // true
-     * Amount.from(-100).isPositive(); // false
-     * Amount.from(0).isPositive();    // false
-     * ```
-     */
-    isPositive(): boolean;
-    /**
-     * Checks if this amount is negative
-     *
-     * @returns True if the amount is less than zero
-     *
-     * @example
-     * ```typescript
-     * Amount.from(-100).isNegative(); // true
-     * Amount.from(100).isNegative();  // false
-     * Amount.from(0).isNegative();    // false
-     * ```
-     */
-    isNegative(): boolean;
-    /**
-     * Gets the best locale for this currency
-     * Maps currency codes to their primary locales
-     */
-    private getNativeLocaleForCurrency;
-    /**
-     * Formats using native Intl.NumberFormat with comprehensive options
-     */
-    private formatWithIntl;
-    /**
-     * Manual formatting method (existing logic)
-     */
-    private formatManually;
-    /**
-     * Determines if currency should use spacing (for manual formatting)
-     */
-    private shouldUseSpacing;
-    /**
-     * Enhanced format method with comprehensive options including native formatting
-     *
-     * @param options - Formatting configuration options
-     * @returns Formatted amount string according to specified options
-     *
-     * @example
-     * ```typescript
-     * const amount = Amount.from(-1234.56, 'USD');
-     * const tzAmount = Amount.from(1234.56, 'TZS');
-     *
-     * // Basic formatting (existing behavior)
-     * amount.format(); // "-$1,234.56"
-     *
-     * // Native formatting with proper spacing and locale
-     * tzAmount.format({ useNativeFormatting: true }); // "TSh 1,234.56"
-     * tzAmount.format({ useNativeFormatting: true, useNativeLocale: true }); // Uses Swahili locale
-     *
-     * // Manual formatting with native symbols
-     * amount.format({ useNativeSymbol: true }); // "-$1,234.56"
-     * tzAmount.format({ useNativeSymbol: true }); // "-TSh 1,234.56" (with proper spacing)
-     *
-     * // Advanced native formatting
-     * amount.format({
-     *   useNativeFormatting: true,
-     *   useNativeLocale: true,
-     *   showSign: 'always'
-     * }); // "+$1,234.56" (US formatting)
-     *
-     * // European formatting
-     * Amount.from(1234.56, 'EUR').format({
-     *   useNativeFormatting: true,
-     *   useNativeLocale: true
-     * }); // "1.234,56 €" (German formatting)
-     *
-     * // Custom formatting (existing behavior preserved)
-     * amount.format({ symbolPosition: 'after', useGrouping: false }); // "-1234.56$"
-     * ```
-     */
-    format(options?: AmountFormatOptions): string;
-    /**
-     * Convenience method for native formatting
-     * @param options Additional formatting options
-     * @returns Formatted string using native currency conventions
-     */
-    formatNative(options?: Omit<AmountFormatOptions, "useNativeFormatting">): string;
-    /**
-     * Enhanced label using native formatting for better UX
-     */
-    get label(): string;
-    /**
-     * International label using consistent formatting
-     */
-    get internationalLabel(): string;
-    /**
-     * Returns the amount as a plain number string without currency symbols
-     *
-     * @param options - Formatting options for the numeric value
-     * @returns Plain numeric string
-     *
-     * @example
-     * ```typescript
-     * Amount.from(-1234.56).toPlainNumber();                    // "-1,234.56"
-     * Amount.from(1000).toPlainNumber({ useGrouping: false });  // "1000.00"
-     * Amount.from(1234.5).toPlainNumber({
-     *   minimumFractionDigits: 4
-     * }); // "1,234.5000"
-     * ```
-     */
-    toPlainNumber(options?: Omit<AmountFormatOptions, "includeSymbol" | "includeCurrency" | "symbolPosition">): string;
-    /**
-     * Formats amount in compact notation (K, M, B, T)
-     *
-     * @param precision - Number of decimal places for compact numbers (default: 1)
-     * @param includeSymbol - Whether to include currency symbol (default: true)
-     * @param options - Additional formatting options
-     * @returns Compact formatted string
-     *
-     * @example
-     * ```typescript
-     * Amount.from(1500).toCompactFormat();        // "$1.5K"
-     * Amount.from(-2500000).toCompactFormat();    // "-$2.5M"
-     * Amount.from(1234567890).toCompactFormat();  // "$1.2B"
-     * Amount.from(999).toCompactFormat();         // "$999"
-     * Amount.from(1000000, 'EUR').toCompactFormat(2); // "€1.00M"
-     * Amount.from(1000000).toCompactFormat(2, true, { alwaysShowDecimals: true }); // "$1.00M"
-     * Amount.from(1500000).toCompactFormat(0);    // "$2M" (rounded)
-     * ```
-     */
-    toCompactFormat(precision?: number, options?: {
-        includeSymbol?: boolean;
-        alwaysShowDecimals?: boolean;
-        roundingMode?: "round" | "floor" | "ceil";
-    }): string;
-    /**
-     * Returns the amount rounded to the nearest whole number
-     *
-     * @param includeSymbol - Whether to include currency symbol (default: false)
-     * @param useGrouping - Whether to use thousands separators (default: true)
-     * @returns Whole number formatted string
-     *
-     * @example
-     * ```typescript
-     * Amount.from(1234.56).toWholeNumber();                // "1,235"
-     * Amount.from(-1234.44).toWholeNumber();               // "-1,234"
-     * Amount.from(1000.5).toWholeNumber(true);             // "$1,001"
-     * Amount.from(999.4).toWholeNumber(false, false);      // "999"
-     * ```
-     */
-    toWholeNumber(includeSymbol?: boolean, useGrouping?: boolean): string;
-    /**
-     * Helper method to get the actual rounded value as a number (for toWholeNumber)
-     *
-     * @returns The amount rounded to the nearest whole number
-     *
-     * @example
-     * ```typescript
-     * Amount.from(1234.56).getWholeValue(); // 1235
-     * Amount.from(-1234.44).getWholeValue(); // -1234
-     * ```
-     */
-    getWholeValue(): number;
-    /**
-   * Serializes the Amount instance to a JSON-compatible object
-   */
-    toJSON(): AmountJSON;
-    /**
-     * Serializes the Amount instance to a JSON string
-     */
-    toJSONString(): string;
-    /**
-     * Creates an Amount instance from a JSON-compatible object or string
-     */
-    static fromJSON(json: AmountJSON | string): Amount | undefined;
-    /**
-     * Creates an Amount instance from a JSON string
-     */
-    static fromJSONString(jsonString: string): Amount | undefined;
-    /**
-     * Type guard to check if an object is a valid AmountJSON using Zod validation
-     */
-    static isAmountJSON(obj: unknown): obj is AmountJSON;
-    /**
-     * Returns the sum of multiple amounts
-     *
-     * Handles arrays containing both positive and negative amounts
-     *
-     * @param amounts - Array of Amount objects to sum
-     * @returns New Amount object with the total sum
-     * @throws {Error} If amounts have different currencies
-     *
-     * @example
-     * ```typescript
-     * const amounts = [
-     *   Amount.from(100),
-     *   Amount.from(-50),
-     *   Amount.from(25)
-     * ];
-     * Amount.sum(amounts); // Amount(75)
-     * ```
-     */
-    static sum(amounts: Amount[]): Amount;
-    /**
-     * Returns the average of multiple amounts
-     *
-     * Handles arrays containing both positive and negative amounts
-     *
-     * @param amounts - Array of Amount objects to average
-     * @returns New Amount object with the average value
-     * @throws {Error} If amounts have different currencies or array is empty
-     *
-     * @example
-     * ```typescript
-     * const amounts = [
-     *   Amount.from(100),
-     *   Amount.from(-200),
-     *   Amount.from(200)
-     * ];
-     * Amount.average(amounts); // Amount(33.33)
-     * ```
-     */
-    static average(amounts: Amount[]): Amount;
-    /**
-     * Returns the minimum amount from an array of amounts
-     *
-     * Properly handles negative amounts (most negative is minimum)
-     *
-     * @param amounts - Array of Amount objects
-     * @returns Amount object with minimum value
-     * @throws {Error} If array is empty
-     *
-     * @example
-     * ```typescript
-     * const amounts = [
-     *   Amount.from(100),
-     *   Amount.from(-200),
-     *   Amount.from(50)
-     * ];
-     * Amount.min(amounts); // Amount(-200)
-     * ```
-     */
-    static min(amounts: Amount[]): Amount;
-    /**
-     * Returns the maximum amount from an array of amounts
-     *
-     * Properly handles negative amounts (least negative is maximum)
-     *
-     * @param amounts - Array of Amount objects
-     * @returns Amount object with maximum value
-     * @throws {Error} If array is empty
-     *
-     * @example
-     * ```typescript
-     * const amounts = [
-     *   Amount.from(100),
-     *   Amount.from(-200),
-     *   Amount.from(50)
-     * ];
-     * Amount.max(amounts); // Amount(100)
-     * ```
-     */
-    static max(amounts: Amount[]): Amount;
-    /**
-     * Checks if the amount is valid
-     *
-     * Now accepts both positive and negative amounts as valid
-     *
-     * @param input - Amount to be checked for validity
-     * @param currencyCode - Currency code to validate against
-     * @returns True if the amount is valid, false otherwise
-     *
-     * @example
-     * ```typescript
-     * Amount.canConstruct(1000);     // true
-     * Amount.canConstruct(-500);     // true
-     * Amount.canConstruct(0);        // true
-     * Amount.canConstruct('abc');    // false
-     * Amount.canConstruct(null);     // false
-     * ```
-     */
-    static canConstruct(input?: string | number | null, currencyCode?: CurrencyCode): boolean;
-    /**
-     * Checks if an unknown value is an Amount instance
-     *
-     * Validates the structural integrity of an amount object, including negative amounts
-     *
-     * @param obj - The value to validate
-     * @returns Type predicate indicating if the value is a valid Amount
-     *
-     * @example
-     * ```typescript
-     * const amount = Amount.from(-100);
-     * Amount.is(amount);  // true
-     * Amount.is({});      // false
-     * Amount.is(null);    // false
-     * ```
-     */
-    static is(obj: unknown): obj is Amount;
-    /**
-     * Checks the validity of the amount data
-     *
-     * @returns True if the amount data is available and valid
-     */
-    validate(): boolean;
-    /**
-     * Gets payout constraints (min/max amounts) for a specific currency
-     *
-     * Returns Amount objects that can be directly compared and formatted,
-     * providing type safety and automatic currency context.
-     *
-     * @param currency - The currency code to get constraints for
-     * @returns Object with min and max Amount objects, or undefined if currency not supported
-     *
-     * @example
-     * ```typescript
-     * const constraints = Amount.getTransactionLimits('TZS');
-     * if (constraints && myAmount.lessThan(constraints.min)) {
-     *   throw new Error(`Minimum amount is ${constraints.min.label}`);
-     * }
-     * ```
-     */
-    static getTransactionLimits(currency: CurrencyCode): {
-        min: Amount;
-        max: Amount;
-    };
-}
-/**
- * Export the Amount class and regex pattern
- */
-export { Amount, AMOUNT_REGEX };