@temboplus/frontend-core 0.4.3 → 1.0.1-beta.0

package/dist/domain/amount/amount.d.ts

@@ -0,0 +1,476 @@
+import type { Currency, CurrencyCode } from "../currency/index.js";
+import type { AmountJSON } from "./amount.schema.js";
+import { type AmountCompactFormatOptions, type AmountFormatOptions } from "./amount.helpers.js";
+/**
+ * Internal symbol used by AmountFactory to bypass the protected constructor.
+ * Importing this from outside the factory is unsupported.
+ */
+export declare const AmountConstructorToken: unique symbol;
+/**
+ * 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');           // TZS 10,000.00
+ * Amount.from('TZS 10,000');         // TZS 10,000.00 (spaces removed)
+ * Amount.from('10000TZS');           // TZS 10,000.00
+ * Amount.from('TZS1,234.56');        // TZS 1,234.56
+ * Amount.from('-TZS1000');           // -TZS 1,000.00
+ * Amount.from('TZS-1000');           // -TZS 1,000.00
+ *
+ * // Traditional usage still works
+ * Amount.from(1000, 'TZS');          // TZS 1,000.00
+ * Amount.from('1000', 'USD');        // USD 1,000.00
+ * ```
+ */
+/**
+ * Plain-object representation of an Amount containing the full state.
+ */
+export interface AmountObject {
+    value: number;
+    text: string;
+    currencyCode: CurrencyCode;
+}
+/**
+ * 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'); // USD 1,000.00
+ * const negative = Amount.from(-500, 'USD');  // -USD 500.00
+ * const fromString = Amount.from('-1,234.56', 'EUR'); // -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;
+    /**
+     * Token-protected constructor. Use AmountFactory factories or the static
+     * delegations on Amount to obtain instances.
+     */
+    constructor(token: symbol, value: number, text: string, currency: Currency);
+    /** Parses arbitrary input into a validated Amount via AmountFactory. */
+    static from(input: string | number, currencyCode?: CurrencyCode | null): Amount | undefined;
+    /** Re-resolves an Amount from its compact JSON identity. */
+    static fromJSON(json: AmountJSON | string): Amount | undefined;
+    /** Re-resolves an Amount from a JSON string. */
+    static fromJSONString(jsonString: string): Amount | undefined;
+    /** Type guard delegating to AmountFactory.isAmount. */
+    static is(obj: unknown): obj is Amount;
+    /**
+     * 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;
+    /**
+     * 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');
+     *
+     * // Default formatting (currency codes)
+     * amount.format(); // "-USD 1,234.56"
+     * tzAmount.format(); // "TZS 1,234.56"
+     *
+     * // Symbol formatting (opt-in)
+     * amount.format({ useSymbol: true }); // "-$1,234.56"
+     * tzAmount.format({ useSymbol: true }); // "TSh 1,234.56"
+     *
+     * // Native formatting with Intl (uses symbols via browser locale)
+     * tzAmount.format({ useNativeFormatting: true, useNativeLocale: true }); // Uses Swahili locale
+     *
+     * // Currency position
+     * amount.format({ currencyPosition: 'after' }); // "-1,234.56 USD"
+     *
+     * // No currency
+     * amount.format({ showCurrency: false }); // "-1,234.56"
+     * ```
+     */
+    format(options?: AmountFormatOptions): string;
+    /**
+     * Convenience method for native formatting using Intl.NumberFormat with symbols
+     * @param options Additional formatting options
+     * @returns Formatted string using native currency conventions with symbols
+     */
+    formatNative(options?: Omit<AmountFormatOptions, "useNativeFormatting">): string;
+    /**
+     * Primary display label using currency codes (e.g., "TZS 1,000.00", "USD 500.00")
+     */
+    get label(): string;
+    /**
+     * International label using currency codes with en-US locale
+     */
+    get internationalLabel(): string;
+    /**
+     * Returns the amount as a plain number string without currency indicator
+     *
+     * @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, "showCurrency" | "useSymbol" | "currencyPosition">): string;
+    /**
+     * Formats amount in compact notation (K, M, B, T)
+     *
+     * @param precision - Number of decimal places for compact numbers (default: 1)
+     * @param options - Additional formatting options
+     * @returns Compact formatted string
+     *
+     * @example
+     * ```typescript
+     * Amount.from(1500).toCompactFormat();        // "TZS 1.5K"
+     * Amount.from(-2500000, 'USD').toCompactFormat();    // "-USD 2.5M"
+     * Amount.from(1234567890, 'USD').toCompactFormat();  // "USD 1.2B"
+     * Amount.from(999, 'USD').toCompactFormat();         // "USD 999"
+     * Amount.from(1000000, 'EUR').toCompactFormat(2, { alwaysShowDecimals: true }); // "EUR 1.00M"
+     * Amount.from(1500000, 'USD').toCompactFormat(0);    // "USD 2M" (rounded)
+     * ```
+     */
+    toCompactFormat(precision?: number, options?: AmountCompactFormatOptions): string;
+    /**
+     * Returns the amount rounded to the nearest whole number
+     *
+     * @param showCurrency - Whether to include currency code (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, 'USD').toWholeNumber(true);      // "USD 1,001"
+     * Amount.from(999.4).toWholeNumber(false, false);      // "999"
+     * ```
+     */
+    toWholeNumber(showCurrency?: 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;
+    /** Full plain-object dump of all current state. */
+    toObject(): AmountObject;
+}
+export { Amount };
+export type { AmountCompactFormatOptions, AmountFormatOptions, } from "./amount.helpers.js";

package/dist/domain/amount/amount.helpers.d.ts

@@ -0,0 +1,64 @@
+import type { Currency } from "../currency/currency.js";
+import type { CurrencyCode } from "../currency/currency.types.js";
+/**
+ * Formatting options for the enhanced format method.
+ */
+export interface AmountFormatOptions {
+    /** Show currency indicator (code by default, or symbol if useSymbol is true). Default: true */
+    showCurrency?: boolean;
+    /** Use currency symbol (e.g., $, TSh) instead of code (e.g., USD, TZS). Default: false */
+    useSymbol?: boolean;
+    /** Position of currency indicator. Default: "before" */
+    currencyPosition?: "before" | "after";
+    /** Use thousands separators (commas). Default: true */
+    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) */
+    useNativeFormatting?: boolean;
+    /** Prefer native locale for the currency (overrides provided locale) */
+    useNativeLocale?: boolean;
+}
+export interface AmountCompactFormatOptions {
+    showCurrency?: boolean;
+    useSymbol?: boolean;
+    alwaysShowDecimals?: boolean;
+    roundingMode?: "round" | "floor" | "ceil";
+}
+interface ParsedCurrencyAmount {
+    currency?: CurrencyCode;
+    amount?: string;
+}
+declare function containsForbiddenCurrencySymbol(input: string): boolean;
+/**
+ * Splits a cleaned currency-prefixed string into { currency, amount }.
+ */
+declare function parseCurrencyAmountInput(cleaned: string, normalizeCurrencyCode: (code: string) => CurrencyCode | undefined): ParsedCurrencyAmount;
+/**
+ * Formats a numeric value into a display string using the currency's decimal
+ * digits.
+ */
+declare function formatAmountText(value: number, currency: Currency): string;
+declare function formatAmountWithIntl(value: number, currency: Currency, options: AmountFormatOptions): string;
+declare function formatAmountManually(value: number, currency: Currency, options: AmountFormatOptions): string;
+declare function formatCompactAmount(value: number, currency: Currency, precision?: number, options?: AmountCompactFormatOptions): string;
+export declare const AmountHelpers: {
+    AMOUNT_REGEX: RegExp;
+    containsForbiddenCurrencySymbol: typeof containsForbiddenCurrencySymbol;
+    formatAmountText: typeof formatAmountText;
+    formatAmountManually: typeof formatAmountManually;
+    formatAmountWithIntl: typeof formatAmountWithIntl;
+    formatCompactAmount: typeof formatCompactAmount;
+    parseCurrencyAmountInput: typeof parseCurrencyAmountInput;
+};
+export {};

package/dist/domain/amount/amount.schema.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+/**
+ * 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;
+}>;
+/**
+ * Compact JSON identity for an Amount, sufficient to reconstruct the value via
+ * AmountFactory.
+ */
+export type AmountJSON = z.infer<typeof AmountJSONSchema>;
+/**
+ * @deprecated Use AmountJSON instead.
+ */
+export type AmountJson = AmountJSON;

package/dist/domain/amount/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./amount.js";
+export { AmountHelpers } from "./amount.helpers.js";
+export type { AmountCompactFormatOptions, AmountFormatOptions, } from "./amount.helpers.js";
+export * from "./amount.schema.js";

package/dist/domain/bank/bank.d.ts

@@ -0,0 +1,59 @@
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import { z } from "zod";
+import { BankJSONSchema } from "./bank.schema.js";
+import type { BankSwiftCode, KEBankSwiftCode, TZBankSwiftCode } from "./bank.types.js";
+/**
+ * Internal symbol used by BankFactory to bypass the protected constructor.
+ * Importing this from outside the factory is unsupported.
+ */
+export declare const BankConstructorToken: unique symbol;
+/**
+ * Compact JSON identity for a Bank, sufficient to re-resolve the canonical
+ * record via BankRegistry.
+ */
+export type BankJSON = z.infer<typeof BankJSONSchema>;
+/**
+ * Plain-object representation of a Bank containing the full state.
+ */
+export interface BankObject {
+    officialName: string;
+    shortName: string;
+    bic: TZBankSwiftCode | KEBankSwiftCode;
+    countryCode: ISO2CountryCode;
+    formerNames?: string[];
+}
+/**
+ * Pure value object representing a bank. Lookups, validation, and factories
+ * live on BankRegistry; the static methods on this class are thin delegations
+ * for ergonomic call sites.
+ */
+export declare class Bank {
+    readonly officialName: string;
+    readonly shortName: string;
+    readonly bic: TZBankSwiftCode | KEBankSwiftCode;
+    readonly countryCode: ISO2CountryCode;
+    readonly formerNames?: string[];
+    constructor(token: symbol, officialName: string, shortName: string, bic: TZBankSwiftCode | KEBankSwiftCode, countryCode: ISO2CountryCode, formerNames?: string[]);
+    /** Whether this bank has any former names recorded. */
+    hasFormerNames(): boolean;
+    /** Display string with former names appended in parentheses. */
+    getDisplayNameWithHistory(): string;
+    /** Human-readable label, e.g. "CRDB BANK PLC (CRDB) - BIC: CORUTZTZ [TZ]". */
+    toString(): string;
+    /** Compact JSON identity for serialization. */
+    toJSON(): BankJSON;
+    toJSONString(): string;
+    /** Full plain-object dump of all current state. */
+    toObject(): BankObject;
+    /**
+     * Resolves a Bank by BIC/SWIFT code. If the country is omitted, the registry
+     * searches across every supported country.
+     */
+    static fromBIC(bic: BankSwiftCode | string, countryCode?: ISO2CountryCode): Bank | undefined;
+    /** Re-resolves a Bank from its compact JSON identity. */
+    static fromJSON(json: BankJSON | string): Bank | undefined;
+    /** Re-resolves a Bank from a JSON string. */
+    static fromJSONString(jsonString: string): Bank | undefined;
+    /** Type guard delegating to BankFactory.isBank. */
+    static is(obj: unknown): obj is Bank;
+}

package/dist/domain/bank/bank.helpers.d.ts

@@ -0,0 +1,29 @@
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import { isBankSwiftCode, type BankSwiftCode } from "./bank.types.js";
+export declare const BankHelpers: {
+    isBankSwiftCode: typeof isBankSwiftCode;
+    validateAccountNumber: typeof validateAccountNumber;
+    validateSwiftCode: typeof validateSwiftCode;
+    validateAllBankDetails: typeof validateAllBankDetails;
+    getCountryFromSwiftCode: typeof getCountryFromSwiftCode;
+};
+/**
+ * Validates a bank account number format. When countryCode is omitted, every
+ * supported country validator is checked.
+ */
+declare function validateAccountNumber(accountNumber: string, countryCode?: ISO2CountryCode): boolean;
+/**
+ * Validates a SWIFT/BIC code. When countryCode is omitted, every supported
+ * country validator is checked.
+ */
+declare function validateSwiftCode(swiftCode: string, countryCode?: ISO2CountryCode): swiftCode is BankSwiftCode;
+/**
+ * Validates all bank details. When countryCode is omitted, account number and
+ * SWIFT validation each scan every supported country.
+ */
+declare function validateAllBankDetails(accountNumber: string, swiftCode: string, accountName: string, countryCode?: ISO2CountryCode): boolean;
+/**
+ * Determines which country a SWIFT code belongs to.
+ */
+declare function getCountryFromSwiftCode(swiftCode: string): ISO2CountryCode | undefined;
+export {};