@temboplus/frontend-core 0.2.10 → 0.2.12

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

@@ -0,0 +1,733 @@
+import { CurrencyCode } from "../../models/currency";
+/**
+ * Regular expression for validating amount strings
+ * Supports both positive and negative amounts with optional comma separators and decimals
+ *
+ * Pattern breakdown:
+ * - ^-? : Optional minus sign at the start (for negative amounts)
+ * - (?:\d{1,3}(?:,\d{3})*|\d+) : Either:
+ *   - \d{1,3}(?:,\d{3})* : 1-3 digits followed by groups of comma + 3 digits (e.g., "1,234,567")
+ *   - |\d+ : OR just any sequence of digits (e.g., "1234567")
+ * - (?:\.\d+)? : Optional decimal part with any number of digits
+ * - $ : End of string
+ *
+ * Valid examples: "123", "-456", "1,234", "-1,234.56", "0", "-0.50"
+ * Invalid examples: "12.34.56", "1,23", "-", "abc", "1,,234"
+ */
+declare const AMOUNT_REGEX: RegExp;
+/**
+ * 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 a string or number input
+     *
+     * Supports various input formats:
+     * - Numbers: 1000, -500, 0, 123.45, -67.89
+     * - Strings: "1000", "-500", "1,234", "-1,234.56"
+     * - Currency symbols are automatically removed from strings
+     *
+     * @param input - The input value (string or number, positive or negative)
+     * @param currencyCode - The currency code (defaults to TZS)
+     * @returns Amount instance or undefined if validation fails
+     *
+     * @example
+     * ```typescript
+     * Amount.from(1000);           // Valid: TSh 1,000.00
+     * Amount.from(-500, 'USD');    // Valid: -$500.00
+     * Amount.from('-1,234.56');    // Valid: -TSh 1,234.56
+     * Amount.from('abc');          // Invalid: returns undefined
+     * Amount.from('');             // Invalid: returns undefined
+     * ```
+     */
+    static from(input: string | number, currencyCode?: CurrencyCode | null): Amount | undefined;
+    /**
+     * 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
+     *
+     * This method creates a plain object representation that can be safely
+     * serialized to JSON without losing any essential data.
+     *
+     * @returns {AmountJson} A plain object containing all necessary Amount data
+     *
+     * @example
+     * ```typescript
+     * const amount = Amount.from(-1234.56, 'USD');
+     * const json = amount.toJson();
+     * console.log(json);
+     * // {
+     * //   value: -1234.56,
+     * //   text: "1,234.56",
+     * //   currencyCode: "USD",
+     * //   version: "1.0"
+     * // }
+     *
+     * // Can be safely stringified
+     * const jsonString = JSON.stringify(json);
+     * ```
+     */
+    toJson(): AmountJson;
+    /**
+     * Creates an Amount instance from a JSON-compatible object
+     *
+     * This static method reconstructs an Amount instance from data that was
+     * previously serialized using toJson(). It validates the input data and
+     * ensures the resulting Amount is valid.
+     *
+     * @param {AmountJson | string} json - Either an AmountJson object or a JSON string
+     * @returns {Amount | undefined} An Amount instance if valid, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * // From object
+     * const jsonData = {
+     *   value: -1234.56,
+     *   text: "1,234.56",
+     *   currencyCode: "USD",
+     *   version: "1.0"
+     * };
+     * const amount = Amount.fromJson(jsonData);
+     *
+     * // From JSON string
+     * const jsonString = '{"value":-1234.56,"text":"1,234.56","currencyCode":"USD","version":"1.0"}';
+     * const amount2 = Amount.fromJson(jsonString);
+     *
+     * // Both create equivalent Amount instances
+     * console.log(amount?.label); // "-$1,234.56"
+     * console.log(amount2?.label); // "-$1,234.56"
+     * ```
+     */
+    static fromJson(json: AmountJson | string): Amount | undefined;
+    /**
+     * Type guard to check if an object is a valid AmountJson
+     *
+     * @param obj - The object to validate
+     * @returns True if the object conforms to AmountJson structure
+     *
+     * @example
+     * ```typescript
+     * const data = { value: 100, text: "100.00", currencyCode: "USD" };
+     * if (Amount.isAmountJson(data)) {
+     *   const amount = Amount.fromJson(data);
+     * }
+     * ```
+     */
+    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;
+}
+/**
+ * Export the Amount class and regex pattern
+ */
+export { Amount, AMOUNT_REGEX };