@temboplus/frontend-core 0.4.4 → 1.0.1-beta.1

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+export declare const TZBankSWIFTCodeSchema: z.ZodEffects<z.ZodString, string, string>;
+export declare const KEBankSWIFTCodeSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+* Zod schema for Bank JSON serialization
+* This schema validates the JSON representation of a Bank instance
+*/
+export declare const BankJSONSchema: z.ZodEffects<z.ZodObject<{
+    /** The BIC code for the bank's head office */
+    bic: z.ZodOptional<z.ZodString>;
+    /**
+     * @deprecated Use `bic` instead.
+     */
+    swiftCode: z.ZodOptional<z.ZodString>;
+    /** The ISO 3166-1 alpha-2 country code */
+    countryCode: z.ZodString;
+    /** Version for future compatibility */
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    countryCode: string;
+    bic?: string | undefined;
+    swiftCode?: string | undefined;
+}, {
+    countryCode: string;
+    version?: string | undefined;
+    bic?: string | undefined;
+    swiftCode?: string | undefined;
+}>, {
+    version: string;
+    countryCode: string;
+    bic?: string | undefined;
+    swiftCode?: string | undefined;
+}, {
+    countryCode: string;
+    version?: string | undefined;
+    bic?: string | undefined;
+    swiftCode?: string | undefined;
+}>;

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

@@ -0,0 +1,9 @@
+export declare const KEBankSwiftCodesSet: Set<string>;
+export declare const TZBankSwiftCodesSet: Set<string>;
+export type KEBankSwiftCode = "ABNGKENA" | "ABCLKENA" | "AFRIKENX" | "BARBKENA" | "CRMFKENA" | "CHFIKENX" | "CITIKENA" | "KCOOKENA" | "MYBKKENA" | "CONKKENA" | "CRBTKENA" | "DEVKKENA" | "DTKEKENA" | "DUIBKENA" | "ECOCKENA" | "EQBLKENA" | "FABLKENA" | "FAUMKENA" | "GTBIKENA" | "GUARKENA" | "GAFRKENA" | "HBZUKENA" | "HFCOKENA" | "IMBLKENA" | "KWMIKENX" | "CIFIKENA" | "MORBKENA" | "MIEKKENA" | "NBKEKENX" | "CBAFKENX" | "PAUTKENA" | "IFCBKENA" | "PRIEKENX" | "SBMKKENA" | "SIDNKENA" | "SBICKENX" | "SCBLKENX" | "VICMKENA";
+export type TZBankSwiftCode = "CORUTZTZ" | "PBZATZTZ" | "SCBLTZTX" | "SBICTZTX" | "CITITZTZ" | "EUAFTZTZ" | "DTKETZTZ" | "AKCOTZTZ" | "EXTNTZTZ" | "KLMJTZTZ" | "NLCBTZTX" | "NMIBTZTZ" | "KCBLTZTZ" | "HABLTZTZ" | "BKMYTZTZ" | "BARCTZTZ" | "IMBLTZTZ" | "CBAFTZTZ" | "DASUTZTZ" | "BARBTZTZ" | "AZANTZTZ" | "UCCTTZTZ" | "FMBZTZTX" | "ACTZTZTZ" | "BKIDTZTZ" | "UNAFTZTZ" | "MKCBTZTZ" | "ECOCTZTZ" | "MWCBTZTZ" | "FIRNTZTX" | "AMNNTZTZ" | "EQBLTZTZ" | "TAPBTZTZ" | "MBTLTZTZ" | "CNRBTZTZ" | "MWCOTZTZ" | "GTBITZTZ" | "YETMTZTZ" | "CDSHTZTZ";
+export type BankSwiftCode = KEBankSwiftCode | TZBankSwiftCode;
+/**
+ * Type guard to check whether a string is a known bank SWIFT/BIC code.
+ */
+export declare function isBankSwiftCode(code: string): code is BankSwiftCode;

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

@@ -0,0 +1,4 @@
+export * from "./bank.js";
+export * from "./bank.types.js";
+export { BankHelpers } from "./bank.helpers.js";
+export * from "./bank.schema.js";

package/dist/domain/channel/channel.d.ts

@@ -0,0 +1,40 @@
+import { ChannelType, TransactionDirection } from "./channel.enums.js";
+import type { ChannelData } from "./channel.types.js";
+/**
+ * Plain-object representation of a Channel containing the full state.
+ */
+export interface ChannelObject extends ChannelData {
+    channelType: ChannelType;
+}
+/**
+ * Normalized payment channel returned by TemboCoverage.
+ *
+ * A channel can be a bank or a mobile-money provider. The common shape lets
+ * consumers list payout and collection options without branching on every model.
+ */
+export declare class Channel {
+    readonly id: string;
+    readonly type: ChannelType;
+    readonly countryCode: ChannelData["countryCode"];
+    readonly displayName: string;
+    readonly directions: TransactionDirection[];
+    readonly providerId?: string;
+    readonly bankBic?: string;
+    /**
+     * Creates an immutable channel value from bank or provider coverage data.
+     */
+    constructor(data: ChannelData);
+    /**
+     * Checks whether this channel supports a requested transaction direction.
+     */
+    supportsDirection(direction: TransactionDirection): boolean;
+    /**
+     * Alias for callers that prefer the explicit coverage naming.
+     */
+    get channelType(): ChannelType;
+    /**
+     * Returns a serializable representation for UI lists or API payload assembly.
+     */
+    toObject(): ChannelObject;
+    toString(): string;
+}

package/dist/domain/channel/channel.enums.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Supported payment channel categories.
+ */
+export declare enum ChannelType {
+    BANK = "bank",
+    MOBILE_MONEY = "mobile_money"
+}
+/**
+ * Transaction flows supported by Tembo coverage data.
+ */
+export declare enum TransactionDirection {
+    PAYOUT = "payout",
+    COLLECTION = "collection"
+}

package/dist/domain/channel/channel.types.d.ts

@@ -0,0 +1,12 @@
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import type { BankSwiftCode } from "@domain/bank/bank.types.js";
+import type { ChannelType, TransactionDirection } from "./channel.enums.js";
+export interface ChannelData {
+    id: string;
+    type: ChannelType;
+    countryCode: ISO2CountryCode;
+    displayName: string;
+    directions: TransactionDirection[];
+    providerId?: string;
+    bankBic?: BankSwiftCode | string;
+}

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

@@ -0,0 +1,3 @@
+export * from "./channel.enums.js";
+export * from "./channel.types.js";
+export * from "./channel.js";

package/dist/domain/country/country.d.ts

@@ -0,0 +1,73 @@
+import type { CurrencyCode } from "@domain/currency/currency.types.js";
+import { z } from "zod";
+import { CountryJSONSchema } from "./country.schema.js";
+import type { CountryCode, ISO2CountryCode, ISO3CountryCode } from "./country.types.js";
+import { CONTINENT, SUB_REGION } from "./country.enums.js";
+export { CONTINENT, SUB_REGION } from "./country.enums.js";
+/**
+ * Internal symbol used by CountryFactory to bypass the protected constructor.
+ * Importing this from outside the factory is unsupported.
+ */
+export declare const CountryConstructorToken: unique symbol;
+/**
+ * Compact JSON identity for a Country, sufficient to re-resolve the canonical
+ * record via CountryRegistry.
+ */
+export type CountryJSON = z.infer<typeof CountryJSONSchema>;
+/**
+ * Plain-object representation of a Country containing the full state.
+ */
+export interface CountryObject {
+    code: ISO2CountryCode;
+    iso3: ISO3CountryCode;
+    name: string;
+    nameOfficial: string;
+    flagEmoji: string;
+    continent: CONTINENT;
+    region: SUB_REGION;
+    currencyCode: CurrencyCode | null;
+    dialCode: number;
+}
+/**
+ * Pure value object representing a country. Lookups, validation, and factories
+ * live on CountryRegistry; the static methods on this class are thin delegations
+ * for ergonomic call sites.
+ */
+export declare class Country {
+    private readonly _name;
+    private readonly _iso2;
+    private readonly _nameOfficial;
+    private readonly _iso3;
+    private readonly _flagEmoji;
+    private readonly _continent;
+    private readonly _region;
+    private readonly _currencyCode;
+    private readonly _dialCode;
+    constructor(token: symbol, _name: string, _iso2: ISO2CountryCode, _nameOfficial: string, _iso3: ISO3CountryCode, _flagEmoji: string, _continent: CONTINENT, _region: SUB_REGION, _currencyCode: CurrencyCode | null, _dialCode: number);
+    get name(): string;
+    get code(): ISO2CountryCode;
+    get nameOfficial(): string;
+    get iso3(): ISO3CountryCode;
+    get flagEmoji(): string;
+    get continent(): CONTINENT;
+    get region(): SUB_REGION;
+    get currencyCode(): CurrencyCode | null;
+    get dialCode(): number;
+    /** Human-readable label, e.g. "Tanzania (TZ)". */
+    toString(): string;
+    /** Detailed label including flag and ISO-3 code. */
+    toDetailedString(): string;
+    /** Compact JSON identity for serialization. */
+    toJSON(): CountryJSON;
+    toJSONString(): string;
+    /** Full plain-object dump of all current state. */
+    toObject(): CountryObject;
+    /** Resolves a Country by its ISO-2 or ISO-3 code (case-insensitive). */
+    static fromCode(code: CountryCode | string): Country | undefined;
+    /** Re-resolves a Country from its compact JSON identity. */
+    static fromJSON(json: CountryJSON | string): Country | undefined;
+    /** Re-resolves a Country from a JSON string. */
+    static fromJSONString(jsonString: string): Country | undefined;
+    /** Type guard delegating to CountryFactory.isCountry. */
+    static is(obj: unknown): obj is Country;
+}

package/dist/domain/country/country.enums.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Continents as represented in the country dataset.
+ *
+ * This enum lives in its own module so factories and registries can import it
+ * without going through `country.ts`. Importing enums from `country.ts` while
+ * `country.ts` still imports the factory creates a module-init-time cycle
+ * (the factory module evaluates before `country.ts` finishes declaring its
+ * exports), which leaves the enum reference `undefined` when used in `const`
+ * initializers.
+ */
+export declare enum CONTINENT {
+    AFRICA = "Africa",
+    ANTARCTICA = "Antarctica",
+    ASIA = "Asia",
+    EUROPE = "Europe",
+    NORTH_AMERICA = "North America",
+    OCEANIA = "Oceania",
+    SOUTH_AMERICA = "South America"
+}
+/**
+ * UN sub-regions as represented in the country dataset.
+ */
+export declare enum SUB_REGION {
+    AUSTRALIA_AND_NEW_ZEALAND = "Australia and New Zealand",
+    CARIBBEAN = "Caribbean",
+    CENTRAL_AMERICA = "Central America",
+    CENTRAL_ASIA = "Central Asia",
+    EASTERN_AFRICA = "Eastern Africa",
+    EASTERN_ASIA = "Eastern Asia",
+    EASTERN_EUROPE = "Eastern Europe",
+    MELANESIA = "Melanesia",
+    MICRONESIA = "Micronesia",
+    MIDDLE_AFRICA = "Middle Africa",
+    NORTHERN_AFRICA = "Northern Africa",
+    NORTHERN_AMERICA = "Northern America",
+    NORTHERN_EUROPE = "Northern Europe",
+    POLYNESIA = "Polynesia",
+    SOUTH_EASTERN_ASIA = "South-eastern Asia",
+    SOUTHERN_AFRICA = "Southern Africa",
+    SOUTHERN_ASIA = "Southern Asia",
+    SOUTHERN_EUROPE = "Southern Europe",
+    WESTERN_AFRICA = "Western Africa",
+    WESTERN_ASIA = "Western Asia",
+    WESTERN_EUROPE = "Western Europe"
+}

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

@@ -0,0 +1,6 @@
+import { isCountryCode, isISO2CountryCode, isISO3CountryCode } from "./country.types.js";
+export declare const CountryHelpers: {
+    isISO2Code: typeof isISO2CountryCode;
+    isISO3Code: typeof isISO3CountryCode;
+    isCountryCode: typeof isCountryCode;
+};

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

@@ -0,0 +1,73 @@
+import { z } from "zod";
+/**
+ * Zod schema for Country JSON serialization
+ * This schema validates the JSON representation of a Country instance
+ */
+export declare const CountryJSONSchema: z.ZodObject<{
+    /** The ISO 3166-1 alpha-2 country code */
+    code: z.ZodString;
+    /** Version for future compatibility */
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    version: string;
+}, {
+    code: string;
+    version?: string | undefined;
+}>;
+/**
+ * Zod schema for validating ISO 3166-1 alpha-2 country codes.
+ *
+ * This schema checks if a given string is a valid ISO 3166-1 alpha-2 country code
+ * by checking against the predefined set of valid codes.
+ *
+ * @example
+ * const result = iso2CountryCodeSchema.safeParse("US");
+ * if (result.success) {
+ *   console.log("Valid ISO2 country code");
+ * } else {
+ *   console.error("Invalid ISO2 country code");
+ * }
+ */
+export declare const ISO2CountryCodeSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Zod schema for validating ISO 3166-1 alpha-3 country codes.
+ *
+ * This schema checks if a given string is a valid ISO 3166-1 alpha-3 country code
+ * by checking against the predefined set of valid codes.
+ *
+ * @example
+ * const result = iso3CountryCodeSchema.safeParse("USA");
+ * if (result.success) {
+ *  console.log("Valid ISO3 country code");
+ * } else {
+ *  console.error("Invalid ISO3 country code");
+ * }
+ */
+export declare const ISO3CountryCodeSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Zod schema for validating either ISO 3166-1 alpha-2 or alpha-3 country codes.
+ *
+ * This schema allows for flexibility in accepting both two-letter and three-letter
+ * country codes, making it useful for functions that need to handle both formats.
+ *
+ * @example
+ * const result = countryCodeSchema.safeParse("US");
+ * if (result.success) {
+ *   console.log("Valid country code");
+ * } else {
+ *   console.error("Invalid country code");
+ * }
+ */
+export declare const CountryCodeSchema: z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodEffects<z.ZodString, string, string>, z.ZodObject<{
+    /** The ISO 3166-1 alpha-2 country code */
+    code: z.ZodString;
+    /** Version for future compatibility */
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    version: string;
+}, {
+    code: string;
+    version?: string | undefined;
+}>]>;

package/{script/src/models/country/types.d.ts → dist/domain/country/country.types.d.ts}

@@ -60,4 +60,21 @@ export declare const ISO3CountryCodesSet: Set<string>;
  * @see ISO3CountryCode - For three-letter country codes only
  */
 export type CountryCode = ISO2CountryCode | ISO3CountryCode;
-//# sourceMappingURL=types.d.ts.map
+/**
+ * Type guard to check if a string is a valid ISO2CountryCode.
+ * @param code The string to check.
+ * @returns True if the string is a member of the ISO2CountryCode union type, false otherwise.
+ */
+export declare function isISO2CountryCode(code: string): code is ISO2CountryCode;
+/**
+ * Type guard to check if a string is a valid ISO3CountryCode.
+ * @param code The string to check.
+ * @returns True if the string is a member of the ISO3CountryCode union type, false otherwise.
+ */
+export declare function isISO3CountryCode(code: string): code is ISO3CountryCode;
+/**
+ * Type guard to check if a string is a valid CountryCode.
+ * @param code The string to check.
+ * @returns True if the string is a valid ISO-2 or ISO-3 country code.
+ */
+export declare function isCountryCode(code: string): code is CountryCode;

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

@@ -0,0 +1,4 @@
+export * from "./country.js";
+export * from "./country.types.js";
+export { CountryHelpers } from "./country.helpers.js";
+export * from "./country.schema.js";

package/dist/domain/currency/currency.d.ts

@@ -0,0 +1,62 @@
+import type { CurrencyCode } from "./currency.types.js";
+import { z } from "zod";
+import { CurrencyJSONSchema } from "./currency.schema.js";
+/**
+ * Internal symbol used by CurrencyFactory to bypass the protected constructor.
+ * Importing this from outside the factory is unsupported.
+ */
+export declare const CurrencyConstructorToken: unique symbol;
+/**
+ * Compact JSON identity for a Currency, sufficient to re-resolve the canonical
+ * record via CurrencyRegistry.
+ */
+export type CurrencyJSON = z.infer<typeof CurrencyJSONSchema>;
+/**
+ * Plain-object representation of a Currency containing the full state.
+ */
+export interface CurrencyObject {
+    code: CurrencyCode;
+    name: string;
+    namePlural: string;
+    symbol: string;
+    symbolNative: string;
+    decimalDigits: number;
+    rounding: number;
+}
+/**
+ * Pure value object representing an ISO 4217 currency. Lookups, validation, and
+ * lookups live on CurrencyRegistry; the static methods on this class are thin
+ * delegations for ergonomic call sites.
+ */
+export declare class Currency {
+    private readonly _symbol;
+    private readonly _name;
+    private readonly _symbolNative;
+    private readonly _decimalDigits;
+    private readonly _rounding;
+    private readonly _code;
+    private readonly _namePlural;
+    constructor(token: symbol, _symbol: string, _name: string, _symbolNative: string, _decimalDigits: number, _rounding: number, _code: CurrencyCode, _namePlural: string);
+    get symbol(): string;
+    get name(): string;
+    get symbolNative(): string;
+    get decimalDigits(): number;
+    get rounding(): number;
+    get code(): CurrencyCode;
+    get namePlural(): string;
+    /** Human-readable label, e.g. "US Dollar (USD)". */
+    toString(): string;
+    /** Compact JSON identity for serialization. */
+    toJSON(): CurrencyJSON;
+    toJSONString(): string;
+    /** Full plain-object dump of all current state. */
+    toObject(): CurrencyObject;
+    /** Resolves a Currency by ISO 4217 code (case-insensitive). */
+    static fromCode(code: CurrencyCode | string): Currency | undefined;
+    /** Re-resolves a Currency from its compact JSON identity. */
+    static fromJSON(json: CurrencyJSON | string): Currency | undefined;
+    /** Re-resolves a Currency from a JSON string. */
+    static fromJSONString(jsonString: string): Currency | undefined;
+    /** Type guard delegating to CurrencyFactory.isCurrency. */
+    static is(obj: unknown): obj is Currency;
+}

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

@@ -0,0 +1,4 @@
+import { isCurrencyCode } from "./currency.types.js";
+export declare const CurrencyHelpers: {
+    isCode: typeof isCurrencyCode;
+};

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

@@ -0,0 +1,24 @@
+import { z } from "zod";
+/**
+ * Zod schema for validating ISO 4217 currency codes
+ *
+ * This schema checks if the provided string is a valid ISO 4217 currency code.
+ * If the validation fails, it returns an error message.
+ */
+export declare const CurrencyCodeSchema: z.ZodEffects<z.ZodString, string, string>;
+/**
+ * Zod schema for Currency JSON serialization
+ * This schema validates the JSON representation of a Currency instance
+ */
+export declare const CurrencyJSONSchema: z.ZodObject<{
+    /** The ISO 4217 currency code */
+    code: z.ZodString;
+    /** Version for future compatibility */
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    version: string;
+}, {
+    code: string;
+    version?: string | undefined;
+}>;

package/{script/src/models/currency/types.d.ts → dist/domain/currency/currency.types.d.ts}

@@ -17,5 +17,10 @@
  * Example: "USD" for US Dollar, "EUR" for Euro, "JPY" for Japanese Yen
  */
 export type CurrencyCode = "USD" | "CAD" | "EUR" | "AED" | "AFN" | "ALL" | "AMD" | "ARS" | "AUD" | "AZN" | "BAM" | "BDT" | "BGN" | "BHD" | "BIF" | "BND" | "BOB" | "BRL" | "BWP" | "BYN" | "BZD" | "CDF" | "CHF" | "CLP" | "CNY" | "COP" | "CRC" | "CVE" | "CZK" | "DJF" | "DKK" | "DOP" | "DZD" | "EGP" | "ERN" | "ETB" | "GBP" | "GEL" | "GHS" | "GNF" | "GTQ" | "HKD" | "HNL" | "HRK" | "HUF" | "IDR" | "ILS" | "INR" | "IQD" | "IRR" | "ISK" | "JMD" | "JOD" | "JPY" | "KES" | "KHR" | "KMF" | "KRW" | "KWD" | "KZT" | "LBP" | "LKR" | "LYD" | "MAD" | "MDL" | "MGA" | "MKD" | "MMK" | "MOP" | "MUR" | "MXN" | "MYR" | "MZN" | "NAD" | "NGN" | "NIO" | "NOK" | "NPR" | "NZD" | "OMR" | "PAB" | "PEN" | "PHP" | "PKR" | "PLN" | "PYG" | "QAR" | "RON" | "RSD" | "RUB" | "RWF" | "SAR" | "SDG" | "SEK" | "SGD" | "SOS" | "SSP" | "SYP" | "THB" | "TND" | "TOP" | "TRY" | "TTD" | "TWD" | "TZS" | "UAH" | "UGX" | "UYU" | "UZS" | "VES" | "VND" | "XAF" | "XOF" | "YER" | "ZAR" | "ZMW" | "STN" | "MRU" | "ZWG";
-export declare const ValidCurrencyCodesSet: Set<CurrencyCode>;
-//# sourceMappingURL=types.d.ts.map
+export declare const CurrencyCodesSet: Set<CurrencyCode>;
+/**
+ * Type guard to check if a string is a valid CurrencyCode.
+ * @param code The string to check.
+ * @returns True if the string is a member of the CurrencyCode union type, false otherwise.
+ */
+export declare function isCurrencyCode(code: string): code is CurrencyCode;

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

@@ -0,0 +1,4 @@
+export * from "./currency.js";
+export * from "./currency.types.js";
+export { CurrencyHelpers } from "./currency.helpers.js";
+export * from "./currency.schema.js";

package/{esm/src/models → dist/domain}/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./amount/index.js";
 export * from "./bank/index.js";
-export * from "./phone_number/index.js";
+export * from "./channel/index.js";
+export * from "./phone-number/index.js";
 export * from "./country/index.js";
 export * from "./currency/index.js";
-//# sourceMappingURL=index.d.ts.map
+export * from "./mobile-money-provider/index.js";

package/dist/domain/mobile-money-provider/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./mobile-money-provider.js";
+export * from "./mobile-money-provider.types.js";
+export { MobileMoneyProviderHelpers } from "./mobile-money-provider.helpers.js";
+export * from "./mobile-money-provider.schema.js";

package/dist/domain/mobile-money-provider/mobile-money-provider.d.ts

@@ -0,0 +1,53 @@
+import { ChannelType, TransactionDirection } from "@domain/channel/channel.enums.js";
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import { MobileMoneyProviderJSON } from "./mobile-money-provider.schema.js";
+import type { MobileMoneyProviderData } from "./mobile-money-provider.types.js";
+/**
+ * Plain-object representation of a MobileMoneyProvider containing the full state.
+ */
+export interface MobileMoneyProviderObject extends MobileMoneyProviderData {
+}
+/**
+ * Internal symbol used by MobileMoneyProviderFactory to bypass the protected constructor.
+ * Importing this from outside the factory is unsupported.
+ */
+export declare const MobileMoneyProviderConstructorToken: unique symbol;
+/**
+ * Pure value object representing one supported mobile-money provider in a
+ * country. Lookups, detection, and validation live on MobileMoneyProviderRegistry;
+ * the static methods on this class are thin delegations for ergonomic call sites.
+ */
+export declare class MobileMoneyProvider {
+    readonly id: string;
+    readonly displayName: string;
+    readonly mobileMoneyServiceName: string;
+    readonly countryCode: MobileMoneyProviderData["countryCode"];
+    readonly currencyCode: MobileMoneyProviderData["currencyCode"];
+    readonly directions: TransactionDirection[];
+    readonly requiresExplicitProvider: boolean;
+    readonly phonePrefixes: string[];
+    constructor(token: symbol, data: MobileMoneyProviderData);
+    /** Generic channel type used by TemboCoverage channel listings. */
+    get channelType(): ChannelType;
+    /** Whether this provider supports the requested transaction direction. */
+    supportsDirection(direction: TransactionDirection): boolean;
+    /** Human-readable label, e.g. "M-Pesa (Vodacom) [TZ]". */
+    toString(): string;
+    /** Compact JSON identity for serialization. */
+    toJSON(): MobileMoneyProviderJSON;
+    toJSONString(): string;
+    /** Full plain-object dump of all current state. */
+    toObject(): MobileMoneyProviderObject;
+    /**
+     * Resolves a MobileMoneyProvider by ID. When `countryCode` is omitted, the
+     * factory searches across every supported country.
+     */
+    static fromID(id: string, countryCode?: ISO2CountryCode): MobileMoneyProvider | undefined;
+    /** Re-resolves a MobileMoneyProvider from its compact JSON identity. */
+    static fromJSON(json: MobileMoneyProviderJSON | string): MobileMoneyProvider | undefined;
+    /** Re-resolves a MobileMoneyProvider from a JSON string. */
+    static fromJSONString(jsonString: string): MobileMoneyProvider | undefined;
+    /** Type guard delegating to MobileMoneyProviderFactory.isMobileMoneyProvider. */
+    static is(obj: unknown): obj is MobileMoneyProvider;
+}
+export { type MobileMoneyProviderJSON, MobileMoneyProviderJSONSchema, } from "./mobile-money-provider.schema.js";

package/dist/domain/mobile-money-provider/mobile-money-provider.helpers.d.ts

@@ -0,0 +1,5 @@
+import { isPhonePrefix, isProviderId } from "./mobile-money-provider.types.js";
+export declare const MobileMoneyProviderHelpers: {
+    isProviderId: typeof isProviderId;
+    isPhonePrefix: typeof isPhonePrefix;
+};

package/dist/domain/mobile-money-provider/mobile-money-provider.schema.d.ts

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { ChannelType, TransactionDirection } from "@domain/channel/channel.enums.js";
+export declare const MobileMoneyProviderJSONSchema: z.ZodObject<{
+    id: z.ZodString;
+    countryCode: z.ZodString;
+    channelType: z.ZodDefault<z.ZodLiteral<ChannelType.MOBILE_MONEY>>;
+    direction: z.ZodOptional<z.ZodNativeEnum<typeof TransactionDirection>>;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    countryCode: string;
+    id: string;
+    channelType: ChannelType.MOBILE_MONEY;
+    direction?: TransactionDirection | undefined;
+}, {
+    countryCode: string;
+    id: string;
+    version?: string | undefined;
+    channelType?: ChannelType.MOBILE_MONEY | undefined;
+    direction?: TransactionDirection | undefined;
+}>;
+export type MobileMoneyProviderJSON = z.infer<typeof MobileMoneyProviderJSONSchema>;

package/dist/domain/mobile-money-provider/mobile-money-provider.types.d.ts

@@ -0,0 +1,21 @@
+import type { ISO2CountryCode } from "@domain/country/country.types.js";
+import type { CurrencyCode } from "@domain/currency/currency.types.js";
+import type { TransactionDirection } from "@domain/channel/channel.enums.js";
+export interface MobileMoneyProviderData {
+    id: string;
+    displayName: string;
+    mobileMoneyServiceName: string;
+    countryCode: ISO2CountryCode;
+    currencyCode: CurrencyCode;
+    directions: TransactionDirection[];
+    requiresExplicitProvider: boolean;
+    phonePrefixes: string[];
+}
+/**
+ * Provider IDs are stable uppercase Tembo identifiers, not display names.
+ */
+export declare function isProviderId(value: unknown): value is string;
+/**
+ * Prefixes are national-number prefixes used only when detection is reliable.
+ */
+export declare function isPhonePrefix(value: unknown): value is string;

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

@@ -0,0 +1,4 @@
+export * from "./phone-number.types.js";
+export * from "./phone-number.js";
+export { PhoneNumberHelpers, phoneLogger } from "./phone-number.helpers.js";
+export * from "./phone-number.schema.js";