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

package/dist/domain/phone-number/phone-number.d.ts

@@ -0,0 +1,57 @@
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import type { PhoneNumber as LibPhoneNumberInstance } from "libphonenumber-js";
+import { type ParsedPhoneNumber, PhoneNumberParser } from "./phone-number.parser.js";
+import type { PhoneNumberJSON } from "./phone-number.schema.js";
+import { PhoneNumberFormat, type PhoneNumberParseOptions, type PhoneNumberType } from "./phone-number.types.js";
+/**
+ * Internal symbol used by PhoneNumberFactory to bypass the protected constructor.
+ * Importing this from outside the factory is unsupported.
+ */
+export declare const PhoneNumberConstructorToken: unique symbol;
+/**
+ * Plain-object representation of a PhoneNumber containing the full state.
+ */
+export interface PhoneNumberObject {
+    e164Format: string;
+    countryCode: ISO2CountryCode;
+    compactNumber: string;
+    numberType?: PhoneNumberType;
+}
+/**
+ * Pure value object representing a validated international phone number.
+ * Parsing/formatting goes through libphonenumber-js via the internal parser;
+ * factories and validation live on PhoneNumberFactory.
+ */
+export declare class PhoneNumber {
+    readonly countryCode: ISO2CountryCode;
+    readonly compactNumber: string;
+    readonly e164Format: string;
+    private readonly _parser;
+    private readonly _parsedInfo;
+    constructor(token: symbol, parsedInfo: ParsedPhoneNumber, parser: PhoneNumberParser);
+    /** Validates the phone number using the underlying library. */
+    validate(): boolean;
+    /** Formats the phone number using the requested style. */
+    getWithFormat(format: PhoneNumberFormat): string;
+    /** Returns the type of phone number (e.g. MOBILE, FIXED_LINE) when known. */
+    getNumberType(): PhoneNumberType | undefined;
+    /** Human-readable label, the international format. */
+    get label(): string;
+    /** Underlying instance from libphonenumber-js, exposed for advanced use. */
+    get underlyingInstance(): LibPhoneNumberInstance;
+    /** E.164 string. */
+    toString(): string;
+    /** Compact JSON identity for serialization. */
+    toJSON(): PhoneNumberJSON;
+    toJSONString(): string;
+    /** Full plain-object dump of all current state. */
+    toObject(): PhoneNumberObject;
+    /** Parses a phone number string into a validated PhoneNumber. */
+    static from(input: string, options?: PhoneNumberParseOptions): PhoneNumber | undefined;
+    /** Re-resolves a PhoneNumber from its compact JSON identity. */
+    static fromJSON(json: PhoneNumberJSON | string): PhoneNumber | undefined;
+    /** Re-resolves a PhoneNumber from a JSON string. */
+    static fromJSONString(jsonString: string): PhoneNumber | undefined;
+    /** Type guard delegating to PhoneNumberFactory.isPhoneNumber. */
+    static is(obj: unknown): obj is PhoneNumber;
+}

package/dist/domain/phone-number/phone-number.helpers.d.ts

@@ -0,0 +1,67 @@
+import type { CountryCode } from "@domain/country/country.types.js";
+export declare const phoneLogger: import("pino").Logger<never, boolean>;
+export declare const PhoneNumberHelpers: {
+    /**
+     * Removes all whitespace characters from the given string.
+     *
+     * @param {string} input - The input string.
+     * @returns {string} String with whitespace removed.
+     *
+     * @example
+     * removeSpaces(" 0712 345  678 ") // "0712345678"
+     * removeSpaces("   +255 712 345 678") // "+255712345678"
+     */
+    removeSpaces: (input: string) => string;
+    /**
+     * Strips all formatting characters used to enhance readability in phone numbers.
+     * Preserves only digits and an optional leading '+' if present.
+     *
+     * Characters removed include:
+     * - Whitespace: space, tab, non-breaking space
+     * - Hyphens, dots, slashes: `-`, `.`, `/`
+     * - Brackets: `(`, `)`
+     * - URI prefix: `tel:`
+     * - Extensions like `ext.`, `x`, or `#` and following digits
+     *
+     * @param {string} input - The phone number string to strip.
+     * @returns {string} A cleaned string with only digits and optional '+' prefix.
+     *
+     * @example
+     * stripFormattingCharacters("tel:+255 (712) 345-678") // "+255712345678"
+     * stripFormattingCharacters("0712-345-678 x99") // "0712345678"
+     * stripFormattingCharacters("(+255) 712/345.678 ext. 9") // "+255712345678"
+     * stripFormattingCharacters("712abc345678") // "712abc345678"
+     */
+    stripFormattingCharacters: (input: string) => string;
+    /**
+     * Normalizes a phone number string by:
+     * - Removing all special characters and spaces
+     * - Preserving only digits and a leading '+'
+     * - Ensuring the result starts with a '+' wherever appropriate
+     * - Handling national numbers when default country is provided
+     * - Removing leading '0' when it's a national number prefix
+     *
+     * @param {string} input - The phone number string to normalize
+     * @param {CountryCode} [defaultCountry] - Optional default country code
+     * @returns {string} The normalized phone number string
+     * @throws {Error} If invalid country code provided
+     *
+     * @example
+     * normalizePhoneNumber("+255 (712) 345-678") // "+255712345678"
+     * normalizePhoneNumber("0712 345 678", "TZ") // "+255712345678"
+     * normalizePhoneNumber("255712345678") // "255712345678"
+     */
+    normalizePhoneNumber: (input: string, defaultCountry?: CountryCode) => string;
+    /**
+     * Checks if a string contains only digits or a `+` prefix followed by digits.
+     *
+     * @param {string} input - The input string.
+     * @returns {boolean} True if valid format, false otherwise.
+     *
+     * @example
+     * isOnlyDigitsOrPlus("+255712345678") // true
+     * isOnlyDigitsOrPlus("0712345678") // true
+     * isOnlyDigitsOrPlus("+255-712-345-678") // false
+     */
+    isOnlyDigitsOrPlus: (input: string) => boolean;
+};

package/dist/domain/phone-number/phone-number.parser.d.ts

@@ -0,0 +1,43 @@
+import { type NumberType, type PhoneNumber as LibPhoneNumber } from "libphonenumber-js/max";
+import { PhoneNumberFormat } from "./phone-number.types.js";
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+export interface ParsedPhoneNumber {
+    libInstance: LibPhoneNumber;
+    countryCode: ISO2CountryCode | undefined;
+    compactNumber: string;
+    e164Format: string;
+    isValid: boolean;
+    numberType: NumberType | undefined;
+}
+/**
+ * Internal adapter around libphonenumber-js.
+ *
+ * This parser is intentionally not exported as a public domain service. The
+ * PhoneNumber model uses it to keep library-specific parsing and formatting
+ * details outside the value object.
+ */
+export declare class PhoneNumberParser {
+    private static instance;
+    private constructor();
+    static getInstance(): PhoneNumberParser;
+    /**
+     * Parses a phone number string using libphonenumber-js.
+     * @param numberToParse The raw phone number string.
+     * @param defaultCountry Optional default country code.
+     * @returns A ParsedPhoneNumber object if successful, otherwise undefined.
+     */
+    parse(numberToParse: string, defaultCountry?: ISO2CountryCode): ParsedPhoneNumber | undefined;
+    /**
+     * Validates a previously parsed LibPhoneNumber instance.
+     * @param libInstance The LibPhoneNumber instance from libphonenumber-js.
+     * @returns True if the number is considered valid by the library.
+     */
+    isValid(libInstance: LibPhoneNumber | undefined): boolean;
+    /**
+     * Formats a previously parsed LibPhoneNumber instance.
+     * @param libInstance The LibPhoneNumber instance from libphonenumber-js.
+     * @param formatType Our local PhoneNumberFormat enum value.
+     * @returns The formatted string, or the E.164 format as fallback.
+     */
+    format(libInstance: LibPhoneNumber | undefined, formatType: PhoneNumberFormat): string;
+}

package/dist/domain/phone-number/phone-number.schema.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+/**
+ * Compact JSON identity for a PhoneNumber, sufficient to re-resolve the value
+ * via PhoneNumberFactory.
+ *
+ * E.164 validation rules:
+ * - Starts with '+'
+ * - Followed by country code (1-3 digits, first digit 1-9)
+ * - Total length 8-16 characters including '+'
+ */
+export declare const PhoneNumberJSONSchema: z.ZodObject<{
+    e164Format: z.ZodString;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    e164Format: string;
+}, {
+    e164Format: string;
+    version?: string | undefined;
+}>;
+export type PhoneNumberJSON = z.infer<typeof PhoneNumberJSONSchema>;

package/dist/domain/phone-number/phone-number.types.d.ts

@@ -0,0 +1,72 @@
+import { ISO2CountryCode } from "@domain/country/country.types.js";
+/**
+ * Enumeration for various phone number formats used for display and processing.
+ */
+export declare enum PhoneNumberFormat {
+    /**
+     * International format, typically used for display.
+     * Includes '+' and country code, may include spacing for readability.
+     * (e.g., +1 202 555 0123)
+     * Note: Exact spacing might vary based on library implementation or locale.
+     */
+    INTERNATIONAL = "INTERNATIONAL",
+    /**
+     * National format, typically including national prefix (like '0') and local spacing.
+     * Formatting varies significantly by country.
+     * (e.g., 0712 345 678 for TZ, (213) 373-4253 for US)
+     */
+    NATIONAL = "NATIONAL",
+    /**
+     * Compact national format (National Significant Number).
+     * Typically digits only, without country code or national prefix '0'.
+     * (e.g., 712345678 for TZ, 2133734253 for US)
+     */
+    COMPACT = "COMPACT",
+    /**
+     * RFC3966 URI format for telephone numbers.
+     * (e.g., tel:+1-202-555-0123 or tel:+255712345678)
+     */
+    RFC3966 = "RFC3966",
+    /**
+     * Strict E.164 format. Includes '+' and country code, followed only by digits
+     * with no spacing or formatting characters. Globally unique.
+     * (e.g., +12025550123, +255712345678)
+     */
+    E164 = "E164",
+    /**
+     * International numeric format without the '+' prefix.
+     * Includes country code followed by the National Significant Number (NSN),
+     * digits only, with no formatting characters or separators.
+     * Commonly used in storage, logging, or systems where '+' is unnecessary or undesirable.
+     * (e.g., 12025550123, 255712345678)
+     */
+    INTERNATIONAL_NUMERIC = "INTERNATIONAL_NUMERIC"
+}
+/**
+ * Represents the type of a phone number, mimicking the classification
+ * used by the underlying libphonenumber-js library.
+ */
+export declare enum PhoneNumberType {
+    FIXED_LINE = "FIXED_LINE",
+    MOBILE = "MOBILE",
+    FIXED_LINE_OR_MOBILE = "FIXED_LINE_OR_MOBILE",// Indicates ambiguity between fixed line and mobile
+    TOLL_FREE = "TOLL_FREE",
+    PREMIUM_RATE = "PREMIUM_RATE",
+    SHARED_COST = "SHARED_COST",
+    VOIP = "VOIP",// Voice over IP
+    PERSONAL_NUMBER = "PERSONAL_NUMBER",
+    PAGER = "PAGER",
+    UAN = "UAN",// Universal Access Number
+    VOICEMAIL = "VOICEMAIL",
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * Options for parsing phone numbers
+ */
+export interface PhoneNumberParseOptions {
+    /**
+     * Default country ISO code to use when parsing a non-international number,
+     * or when a dial code is shared by multiple countries.
+     */
+    defaultCountry?: ISO2CountryCode;
+}

package/dist/factories/amount.factory.d.ts

@@ -0,0 +1,50 @@
+import { Amount } from "@domain/amount/amount.js";
+import { type AmountJSON } from "@domain/amount/amount.schema.js";
+import type { CurrencyCode } from "@domain/currency/currency.types.js";
+/**
+ * Owns Amount construction, parsing, validation, and aggregate operations.
+ * Resolves currencies through CurrencyRegistry; never owns currency data itself.
+ */
+export declare class AmountFactory {
+    private static instance;
+    private readonly currencyRegistry;
+    private constructor();
+    static getInstance(): AmountFactory;
+    /**
+     * Parses arbitrary input into a validated Amount. Accepts numeric values or
+     * strings (including currency-prefixed strings like "TZS1000").
+     */
+    create(input: string | number, currencyCode?: CurrencyCode | null): Amount | undefined;
+    /**
+     * Builds an Amount from a numeric value and currency code, rounding to the
+     * currency's native decimal precision.
+     */
+    createFromNumber(value: number, currencyCode: CurrencyCode): Amount | undefined;
+    /** Re-resolves an Amount from its compact JSON identity. */
+    createFromJSON(json: AmountJSON | string): Amount | undefined;
+    /** Re-resolves an Amount from a JSON string. */
+    createFromJSONString(jsonString: string): Amount | undefined;
+    /** Whether the input can be resolved to a valid Amount. */
+    canCreate(input?: string | number | null, currencyCode?: CurrencyCode): boolean;
+    /**
+     * Type guard that an unknown value is a valid Amount instance whose
+     * (value, currency) round-trips through `create`.
+     */
+    isAmount(obj: unknown): obj is Amount;
+    /** Type guard for the compact AmountJSON shape. */
+    isAmountJSON(obj: unknown): obj is AmountJSON;
+    /** Verifies that an Amount instance can still be reconstructed cleanly. */
+    validate(amount: Amount): boolean;
+    /** Sum of every Amount, requiring matching currencies. */
+    sum(amounts: Amount[]): Amount;
+    /** Mean of every Amount, requiring matching currencies and non-empty array. */
+    average(amounts: Amount[]): Amount;
+    /** Smallest Amount in the array (most negative wins). */
+    min(amounts: Amount[]): Amount;
+    /** Largest Amount in the array. */
+    max(amounts: Amount[]): Amount;
+    /** Builds an Amount by validating a numeric string and currency code. */
+    private createFromString;
+    /** Resolves a (possibly mixed-case) currency code to its canonical form. */
+    private normalizeCurrencyCode;
+}

package/dist/factories/bank.factory.d.ts

@@ -0,0 +1,47 @@
+import { Bank, type BankJSON } from "@domain/bank/bank.js";
+import type { BankSwiftCode } from "@domain/bank/bank.types.js";
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import { type RawBank } from "@repositories/bank.repository.js";
+/**
+ * Constructs Bank model instances from raw bank records.
+ *
+ * Registries own lookup/caching; this factory is the only layer that should
+ * call the Bank constructor.
+ */
+export declare class BankFactory {
+    private readonly repository;
+    private static instance;
+    private constructor();
+    static getInstance(): BankFactory;
+    /**
+     * Resolves a Bank by BIC. When `countryCode` is provided the lookup is
+     * scoped to that country; otherwise the repository searches across every
+     * supported country (and falls back to inferring the country from the BIC).
+     */
+    create(bic: BankSwiftCode | string, countryCode?: ISO2CountryCode): Bank | undefined;
+    /**
+     * Builds a Bank directly from a raw bank record. Returns undefined if the
+     * record is missing required fields (officialName / shortName / bic).
+     */
+    createFromRaw(raw: RawBank, countryCode: ISO2CountryCode): Bank | undefined;
+    /** Re-resolves a Bank from its compact JSON identity. */
+    createFromJSON(json: BankJSON | string): Bank | undefined;
+    /** Re-resolves a Bank from a JSON string. */
+    createFromJSONString(jsonString: string): Bank | undefined;
+    /** Whether the input BIC can be resolved to a known Bank. */
+    canCreate(bic?: string | null, countryCode?: ISO2CountryCode): boolean;
+    /**
+     * Type guard that an unknown value is a known Bank instance whose
+     * (bic, countryCode) round-trips through the repository.
+     */
+    isBank(obj: unknown): obj is Bank;
+    /** Type guard for the compact BankJSON shape. */
+    isBankJSON(obj: unknown): obj is BankJSON;
+    /** Parses a JSON value or string into a validated BankJSON. */
+    private parseJSON;
+    /**
+     * SWIFT codes encode the country in characters 5-6. This is used as a fallback
+     * when the caller didn't supply `countryCode` to `create`.
+     */
+    private getCountryCodeFromBIC;
+}

package/dist/factories/country.factory.d.ts

@@ -0,0 +1,40 @@
+import { Country, type CountryJSON } from "@domain/country/country.js";
+import { CountryCode } from "@domain/country/country.types.js";
+import { type RawCountry } from "@repositories/country.repository.js";
+/**
+ * Constructs Country model instances from raw country records.
+ *
+ * Registries own lookup/caching; this factory is the only layer that should
+ * call the Country constructor.
+ */
+export declare class CountryFactory {
+    private readonly repository;
+    private static instance;
+    private constructor();
+    static getInstance(): CountryFactory;
+    /**
+     * Resolves a Country by ISO-2 or ISO-3 code (case-insensitive). Returns
+     * undefined when the code is not in the dataset.
+     */
+    create(countryCode: CountryCode | string): Country | undefined;
+    /**
+     * Builds a Country directly from a raw country record. The continent and
+     * sub-region strings are normalised to their enum equivalents.
+     */
+    createFromRaw(raw: RawCountry): Country;
+    /** Re-resolves a Country from its compact JSON identity. */
+    createFromJSON(json: CountryJSON | string): Country | undefined;
+    /** Re-resolves a Country from a JSON string. */
+    createFromJSONString(jsonString: string): Country | undefined;
+    /** Whether the input string can be resolved to a known Country. */
+    canCreate(input?: string | null): boolean;
+    /**
+     * Type guard that an unknown value is a known Country instance whose
+     * private name/iso2/iso3 fields match the canonical record.
+     */
+    isCountry(obj: unknown): obj is Country;
+    /** Type guard for the compact CountryJSON shape. */
+    isCountryJSON(obj: unknown): obj is CountryJSON;
+    /** Parses a JSON value or string into a validated CountryJSON. */
+    private parseJSON;
+}

package/dist/factories/currency.factory.d.ts

@@ -0,0 +1,40 @@
+import { Currency, type CurrencyJSON } from "@domain/currency/currency.js";
+import { CurrencyCode } from "@domain/currency/currency.types.js";
+import { type RawCurrency } from "@repositories/currency.repository.js";
+/**
+ * Constructs Currency model instances from validated raw records.
+ *
+ * Registries own lookup/caching; this factory is the only layer that should
+ * call the Currency constructor.
+ */
+export declare class CurrencyFactory {
+    private readonly repository;
+    private static instance;
+    private constructor();
+    static getInstance(): CurrencyFactory;
+    /**
+     * Resolves a Currency by ISO 4217 code (case-insensitive). Returns
+     * undefined when the code is not in the dataset.
+     */
+    create(code: CurrencyCode | string): Currency | undefined;
+    /**
+     * Builds a Currency directly from a raw currency record. Returns undefined
+     * if the record's code isn't a valid ISO 4217 code.
+     */
+    createFromRaw(raw: RawCurrency): Currency | undefined;
+    /** Re-resolves a Currency from its compact JSON identity. */
+    createFromJSON(json: CurrencyJSON | string): Currency | undefined;
+    /** Re-resolves a Currency from a JSON string. */
+    createFromJSONString(jsonString: string): Currency | undefined;
+    /** Whether the input string can be resolved to a known Currency. */
+    canCreate(input?: string | null): boolean;
+    /**
+     * Type guard that an unknown value is a known Currency instance whose
+     * private fields match the dataset.
+     */
+    isCurrency(obj: unknown): obj is Currency;
+    /** Type guard for the compact CurrencyJSON shape. */
+    isCurrencyJSON(obj: unknown): obj is CurrencyJSON;
+    /** Parses a JSON value or string into a validated CurrencyJSON. */
+    private parseJSON;
+}

package/dist/factories/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./amount.factory.js";
+export * from "./bank.factory.js";
+export * from "./country.factory.js";
+export * from "./currency.factory.js";
+export * from "./mobile-money-provider.factory.js";
+export * from "./phone-number.factory.js";
+export * from "./transaction-limit.factory.js";

package/dist/factories/mobile-money-provider.factory.d.ts

@@ -0,0 +1,43 @@
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import type { CurrencyCode } from "@domain/currency/currency.types.js";
+import { MobileMoneyProvider } from "@domain/mobile-money-provider/mobile-money-provider.js";
+import { type MobileMoneyProviderJSON } from "@domain/mobile-money-provider/mobile-money-provider.schema.js";
+import { type RawMobileMoneyProvider } from "@repositories/mobile-money-provider.repository.js";
+/**
+ * Constructs MobileMoneyProvider model instances from raw provider records.
+ *
+ * Registries own lookup/caching; this factory is the only layer that should
+ * call the MobileMoneyProvider constructor.
+ */
+export declare class MobileMoneyProviderFactory {
+    private readonly repository;
+    private static instance;
+    private constructor();
+    static getInstance(): MobileMoneyProviderFactory;
+    /**
+     * Resolves a MobileMoneyProvider by ID. When `countryCode` is provided the
+     * lookup is scoped to that country; otherwise the repository searches across
+     * every supported country.
+     */
+    create(id: string, countryCode?: ISO2CountryCode): MobileMoneyProvider | undefined;
+    /**
+     * Builds a MobileMoneyProvider directly from a raw provider record plus the
+     * country/currency context (typically supplied by the repository or registry).
+     */
+    createFromRaw(raw: RawMobileMoneyProvider, countryCode: ISO2CountryCode, currencyCode: CurrencyCode): MobileMoneyProvider;
+    /** Re-resolves a MobileMoneyProvider from its compact JSON identity. */
+    createFromJSON(json: MobileMoneyProviderJSON | string): MobileMoneyProvider | undefined;
+    /** Re-resolves a MobileMoneyProvider from a JSON string. */
+    createFromJSONString(jsonString: string): MobileMoneyProvider | undefined;
+    /** Whether the input ID can be resolved to a known MobileMoneyProvider. */
+    canCreate(input?: string | null, countryCode?: ISO2CountryCode): boolean;
+    /**
+     * Type guard that an unknown value is a known MobileMoneyProvider instance
+     * whose (id, countryCode) round-trips through `create`.
+     */
+    isMobileMoneyProvider(obj: unknown): obj is MobileMoneyProvider;
+    /** Type guard for the compact MobileMoneyProviderJSON shape. */
+    isMobileMoneyProviderJSON(obj: unknown): obj is MobileMoneyProviderJSON;
+    /** Parses a JSON value or string into a validated MobileMoneyProviderJSON. */
+    private parseJSON;
+}

package/dist/factories/phone-number.factory.d.ts

@@ -0,0 +1,31 @@
+import { PhoneNumber } from "@domain/phone-number/phone-number.js";
+import { type PhoneNumberJSON } from "@domain/phone-number/phone-number.schema.js";
+import type { PhoneNumberParseOptions } from "@domain/phone-number/phone-number.types.js";
+/**
+ * Owns PhoneNumber construction and validation. The model has no dataset, so
+ * there is no PhoneNumberRepository; the factory composes the parser directly.
+ */
+export declare class PhoneNumberFactory {
+    private static instance;
+    private readonly parser;
+    private constructor();
+    static getInstance(): PhoneNumberFactory;
+    /**
+     * Parses arbitrary input into a validated PhoneNumber. Returns undefined when
+     * the input cannot be parsed or fails country-aware validation.
+     */
+    create(input: string, options?: PhoneNumberParseOptions): PhoneNumber | undefined;
+    /** Re-resolves a PhoneNumber from its compact JSON identity. */
+    createFromJSON(json: PhoneNumberJSON | string): PhoneNumber | undefined;
+    /** Re-resolves a PhoneNumber from a JSON string. */
+    createFromJSONString(jsonString: string): PhoneNumber | undefined;
+    /** Whether the input string can be parsed and validated as a phone number. */
+    canCreate(input?: string | null, options?: PhoneNumberParseOptions): boolean;
+    /**
+     * Type guard that an unknown value is a valid PhoneNumber instance whose
+     * E.164 representation re-parses successfully.
+     */
+    isPhoneNumber(obj: unknown): obj is PhoneNumber;
+    /** Type guard for the compact PhoneNumberJSON shape. */
+    isPhoneNumberJSON(obj: unknown): obj is PhoneNumberJSON;
+}

package/dist/factories/transaction-limit.factory.d.ts

@@ -0,0 +1,36 @@
+import type { ChannelType, TransactionDirection } from "@domain/channel/channel.enums.js";
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import type { CurrencyCode } from "@domain/currency/currency.types.js";
+import type { Amount } from "@domain/amount/amount.js";
+import type { RawTransactionLimit } from "@repositories/transaction-limit.repository.js";
+/**
+ * Amount-aware result returned to callers. Wraps the numeric repository values
+ * in `Amount` instances so consumers get currency-correct comparisons and
+ * formatting out of the box.
+ */
+export interface TransactionLimits {
+    countryCode: ISO2CountryCode;
+    currencyCode: CurrencyCode;
+    direction: TransactionDirection;
+    channelType: ChannelType;
+    providerId?: string;
+    min: Amount;
+    max: Amount;
+}
+/**
+ * Converts raw numeric transaction-limit records into amount-aware domain
+ * objects. The repository returns numbers; this factory turns them into
+ * `Amount` instances by way of `AmountFactory`.
+ */
+export declare class TransactionLimitFactory {
+    private static instance;
+    private readonly amountFactory;
+    private constructor();
+    static getInstance(): TransactionLimitFactory;
+    /**
+     * Wraps a raw transaction-limit record (numeric min/max) in a
+     * `TransactionLimits` object whose min/max are `Amount` instances. Returns
+     * undefined when either bound cannot be constructed (e.g. unknown currency).
+     */
+    createFromRaw(raw: RawTransactionLimit): TransactionLimits | undefined;
+}