@temboplus/afloat 0.1.77-beta.2 → 0.1.77-beta.21

package/dist/modules/contact/contact-info.model.d.ts

@@ -2,6 +2,91 @@ import { ContactType, ContactDTO } from "@/modules/contact/contact.dtos.js";
 import { PayoutDTO } from "@/modules/payout/payout.dtos.js";
 import { Bank, ISO2CountryCode, PhoneNumber } from "@temboplus/frontend-core";
 import type { BankSwiftCode, MNOId } from "@temboplus/frontend-core";
+import { z } from "zod";
+export declare const MobileContactInfoJSONSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Mobile">;
+    name: z.ZodString;
+    phoneNumber: z.ZodString;
+    mnoId: z.ZodString;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "Mobile";
+    name: string;
+    version: string;
+    phoneNumber: string;
+    mnoId: string;
+}, {
+    type: "Mobile";
+    name: string;
+    phoneNumber: string;
+    mnoId: string;
+    version?: string | undefined;
+}>;
+export declare const BankContactInfoJSONSchema: z.ZodObject<{
+    type: z.ZodLiteral<"Bank">;
+    accName: z.ZodString;
+    swiftCode: z.ZodString;
+    countryCode: z.ZodString;
+    accNo: z.ZodString;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "Bank";
+    version: string;
+    countryCode: string;
+    accName: string;
+    swiftCode: string;
+    accNo: string;
+}, {
+    type: "Bank";
+    countryCode: string;
+    accName: string;
+    swiftCode: string;
+    accNo: string;
+    version?: string | undefined;
+}>;
+export declare const ContactInfoJSONSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"Mobile">;
+    name: z.ZodString;
+    phoneNumber: z.ZodString;
+    mnoId: z.ZodString;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "Mobile";
+    name: string;
+    version: string;
+    phoneNumber: string;
+    mnoId: string;
+}, {
+    type: "Mobile";
+    name: string;
+    phoneNumber: string;
+    mnoId: string;
+    version?: string | undefined;
+}>, z.ZodObject<{
+    type: z.ZodLiteral<"Bank">;
+    accName: z.ZodString;
+    swiftCode: z.ZodString;
+    countryCode: z.ZodString;
+    accNo: z.ZodString;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: "Bank";
+    version: string;
+    countryCode: string;
+    accName: string;
+    swiftCode: string;
+    accNo: string;
+}, {
+    type: "Bank";
+    countryCode: string;
+    accName: string;
+    swiftCode: string;
+    accNo: string;
+    version?: string | undefined;
+}>]>;
+export type MobileContactInfoJSON = z.infer<typeof MobileContactInfoJSONSchema>;
+export type BankContactInfoJSON = z.infer<typeof BankContactInfoJSONSchema>;
+export type ContactInfoJSON = z.infer<typeof ContactInfoJSONSchema>;
 /**
  * Abstract base class that provides a common interface for different types of contact information.
  * This class defines the structure and validation requirements for both mobile and bank contacts.
@@ -22,8 +107,8 @@ import type { BankSwiftCode, MNOId } from "@temboplus/frontend-core";
  * @example
  * ```typescript
  * // Cannot instantiate directly - use concrete implementations
- * const mobileContact = new MobileContactInfo("John Doe", phoneNumber);
- * const bankContact = new BankContactInfo("Jane Smith", bank, "123456789");
+ * const mobileContact = MobileContactInfo.from({ name: "John Doe", phoneNumber });
+ * const bankContact = BankContactInfo.from({ accName: "Jane Smith", bank, accNo: "123456789" });
  *
  * // Polymorphic usage
  * function processContact(contact: BaseContactInfo) {
@@ -115,6 +200,17 @@ declare abstract class BaseContactInfo {
      * @returns {boolean} True if the contact information is valid
      */
     abstract validate(): boolean;
+    /**
+    * Serializes the ContactInfo instance to a JSON-compatible object
+    */
+    abstract toJSON(): ContactInfoJSON;
+    /**
+     * Converts the ContactInfo instance to a JSON string.
+    */
+    toJSONString(): string;
+    get isMobile(): boolean;
+    get isBank(): boolean;
+    get displayName(): string;
 }
 /**
  * Implementation of BaseContactInfo for mobile phone contacts.
@@ -144,24 +240,16 @@ declare abstract class BaseContactInfo {
  *
  * @example
  * ```typescript
- * // Tanzania - MNO auto-detected from prefix (ignores provided MNO)
- * const tzContact = new MobileContactInfo("John Doe", tzPhoneNumber);
- * console.log(tzContact.channel); // "VODACOM" (auto-detected)
- * console.log(tzContact.countryCode); // "TZ" (from phoneNumber)
- *
- * // Tanzania - Even with explicit MNO, it's auto-detected from prefix
- * const tzExplicit = new MobileContactInfo("John Doe", tzPhoneNumber, TZMNOId.AIRTEL);
- * console.log(tzExplicit.channel); // "VODACOM" (auto-detected, not AIRTEL)
+ * // Preferred: Use static factory method
+ * const tzContact = MobileContactInfo.from({
+ *   name: "John Doe",
+ *   phoneNumber: tzPhoneNumber
+ * });
+ * console.log(tzContact?.channelName); // "M-Pesa" (Vodacom's service)
  *
- * // Kenya - MNO must be explicit due to MNP
- * const keContact = new MobileContactInfo("Jane Smith", kePhoneNumber, KEMNOId.SAFARICOM);
- * console.log(keContact.countryCode); // "KE" (from phoneNumber)
- *
- * // Kenya - This would throw an error (MNO required)
- * // const keContact = new MobileContactInfo("Jane Smith", kePhoneNumber); // ❌ Error
+ * // From JSON
+ * const jsonContact = MobileContactInfo.fromJSON(jsonString);
  * ```
- *
- * @throws {ContactInfoError} When validation fails (invalid name, phone, or MNO)
  */
 export declare class MobileContactInfo extends BaseContactInfo {
     readonly name: string;
@@ -174,147 +262,86 @@ export declare class MobileContactInfo extends BaseContactInfo {
      * 1. Validates name is non-empty
      * 2. Validates phone number structure
      * 3. Extracts country code from PhoneNumber object
-     * 4. Handles MNO validation based on country MNP status:
-     *    - **Countries with MNP (KE)**: Requires explicit MNO, validates it's valid for country
-     *    - **Countries without MNP (TZ)**: Always auto-detects MNO from phone number prefix (ignores provided MNO)
+     * 4. Handles MNO validation based on country MNP status
      *
+     * @deprecated Use {@link MobileContactInfo.from} static factory method instead
      * @param {string} name - The contact's personal name (required, non-empty)
      * @param {PhoneNumber} phoneNumber - The validated phone number object (contains country code)
      * @param {MNOId} [mnoId] - MNO ID. Required for MNP countries (KE), ignored for non-MNP countries (TZ)
      *
-     * @throws {ContactInfoError} When any validation fails:
-     * - Empty or invalid name
-     * - Invalid phone number structure
-     * - Invalid MNO for the country (MNP countries only)
-     * - Missing MNO for MNP countries
-     * - Unable to auto-detect MNO for non-MNP countries
+     * @throws {ContactInfoError} When any validation fails
+     */
+    constructor(name: string, phoneNumber: PhoneNumber, mnoId?: MNOId);
+    /**
+     * Creates a MobileContactInfo instance from data object.
+     * This is the preferred method for creating instances.
+     *
+     * @static
+     * @param {Object} data - The mobile contact data
+     * @param {string} data.name - The contact's personal name
+     * @param {PhoneNumber} data.phoneNumber - The validated phone number object
+     * @param {MNOId} [data.mnoId] - MNO ID (required for MNP countries)
+     *
+     * @returns {MobileContactInfo | undefined} New instance if successful, undefined if validation fails
      *
      * @example
      * ```typescript
-     * try {
-     *   // Tanzania - MNO always auto-detected
-     *   const tzAuto = new MobileContactInfo("John", tzPhone);
-     *   const tzIgnored = new MobileContactInfo("John", tzPhone, TZMNOId.AIRTEL); // AIRTEL ignored, auto-detected from prefix
-     *
-     *   // Kenya - MNO must be explicit
-     *   const keExplicit = new MobileContactInfo("Jane", kePhone, KEMNOId.SAFARICOM);
-     * } catch (error) {
-     *   if (error instanceof ContactInfoError) {
-     *     console.log(`${error.message} - Context:`, error.context);
-     *   }
-     * }
+     * const contact = MobileContactInfo.from({
+     *   name: "John Doe",
+     *   phoneNumber: tzPhone,
+     *   mnoId: TZMNOId.VODACOM // Optional for TZ, required for KE
+     * });
      * ```
      */
-    constructor(name: string, phoneNumber: PhoneNumber, mnoId?: MNOId);
+    static from(data: {
+        name: string;
+        phoneNumber: PhoneNumber;
+        mnoId?: MNOId;
+    }): MobileContactInfo | undefined;
     /**
      * Creates a MobileContactInfo instance from a ContactDTO object.
      * Handles validation and MNO extraction from the DTO's channel field.
-     * The country code is automatically derived from the parsed phone number.
-     *
-     * **Process:**
-     * 1. Validates DTO type is "Mobile"
-     * 2. Parses phone number (extracts country code from E164 format)
-     * 3. Handles MNO based on country MNP status:
-     *    - **MNP countries**: Uses channel field (required)
-     *    - **Non-MNP countries**: Auto-detects from phone number (ignores channel field)
-     * 4. Delegates to constructor for final validation
      *
      * @static
      * @param {ContactDTO} info - The contact data transfer object
-     * @param {string} info.type - Must be "Mobile"
-     * @param {string} info.accountNo - The phone number string to parse (should be E164 format)
-     * @param {string} info.displayName - The contact's name
-     * @param {string} [info.channel] - MNO ID (required for MNP countries, ignored for non-MNP countries)
-     *
      * @returns {MobileContactInfo | undefined} New instance if successful, undefined if validation fails
      *
      * @example
      * ```typescript
-     * // Tanzania DTO - channel ignored, auto-detected from phone number
-     * const tzContactDTO = {
+     * const contactDTO = {
      *   type: "Mobile",
-     *   accountNo: "+255712345678", // Vodacom prefix
+     *   accountNo: "+255712345678",
      *   displayName: "John Doe",
-     *   channel: "AIRTEL" // This will be ignored, Vodacom will be auto-detected
-     * };
-     *
-     * // Kenya DTO - channel required
-     * const keContactDTO = {
-     *   type: "Mobile",
-     *   accountNo: "+254712345678",
-     *   displayName: "Jane Smith",
-     *   channel: "SAFARICOM" // Required for Kenya
+     *   channel: "VODACOM"
      * };
      *
-     * const tzContact = MobileContactInfo.fromContactDTO(tzContactDTO);
-     * console.log(tzContact?.channelId); // "VODACOM" (not "AIRTEL")
-     * console.log(tzContact?.countryCode); // "TZ" (from phone number)
-     *
-     * const keContact = MobileContactInfo.fromContactDTO(keContactDTO);
-     * console.log(keContact?.channelId); // "SAFARICOM"
-     * console.log(keContact?.countryCode); // "KE" (from phone number)
+     * const contact = MobileContactInfo.fromContactDTO(contactDTO);
      * ```
      */
     static fromContactDTO(info: ContactDTO): MobileContactInfo | undefined;
     /**
      * Creates a MobileContactInfo instance from a PayoutDTO object.
      * Extracts mobile contact information from payout data structure.
-     * The country code is derived from the parsed phone number.
-     *
-     * **Process:**
-     * 1. Validates country code format in DTO
-     * 2. Parses phone number from msisdn field (uses DTO country as hint)
-     * 3. Uses phone number's country code (derived from E164 format)
-     * 4. Handles MNO based on country MNP status:
-     *    - **MNP countries**: Uses channel field (required)
-     *    - **Non-MNP countries**: Auto-detects from phone number (ignores channel field)
-     * 5. Uses payeeName as the contact name
-     * 6. Delegates to constructor for validation
      *
      * @static
      * @param {PayoutDTO} info - The payout data transfer object
-     * @param {string} info.msisdn - The phone number in E164 or local format
-     * @param {string} info.countryCode - ISO2 country code (used as parsing hint)
-     * @param {string} info.payeeName - The recipient's name
-     * @param {string} [info.channel] - MNO ID (required for MNP countries, ignored for non-MNP countries)
-     *
      * @returns {MobileContactInfo | undefined} New instance if successful, undefined if parsing fails
      *
      * @example
      * ```typescript
-     * // Tanzania payout - channel ignored
-     * const tzPayoutDTO = {
-     *   msisdn: "+255712345678", // Vodacom prefix
+     * const payoutDTO = {
+     *   msisdn: "+255712345678",
      *   countryCode: "TZ",
      *   payeeName: "John Doe",
-     *   channel: "AIRTEL" // Ignored, Vodacom auto-detected
+     *   channel: "VODACOM"
      * };
      *
-     * // Kenya payout - channel required
-     * const kePayoutDTO = {
-     *   msisdn: "+254712345678",
-     *   countryCode: "KE",
-     *   payeeName: "Jane Smith",
-     *   channel: "SAFARICOM" // Required
-     * };
-     *
-     * const tzContact = MobileContactInfo.fromPayoutDTO(tzPayoutDTO);
-     * console.log(tzContact?.channelName); // "M-Pesa" (Vodacom's service)
-     * console.log(tzContact?.countryCode); // "TZ" (from phoneNumber)
+     * const contact = MobileContactInfo.fromPayoutDTO(payoutDTO);
      * ```
      */
     static fromPayoutDTO(info: PayoutDTO): MobileContactInfo | undefined;
     /**
      * Type guard to validate if an unknown object is a valid MobileContactInfo instance.
-     * Performs comprehensive structural and data validation including country-specific MNO rules.
-     *
-     * **Validation Process:**
-     * 1. **Structural validation**: Checks required properties exist with correct types
-     * 2. **Name validation**: Ensures name is non-empty string
-     * 3. **Phone validation**: Validates phone number can be parsed and is valid
-     * 4. **MNO validation**: Country-specific validation:
-     *    - **MNP countries (KE)**: Validates MNO ID is valid for country
-     *    - **Non-MNP countries (TZ)**: Validates MNO matches phone number prefix (auto-detected)
      *
      * @static
      * @param {unknown} obj - The object to validate
@@ -322,228 +349,56 @@ export declare class MobileContactInfo extends BaseContactInfo {
      *
      * @example
      * ```typescript
-     * const unknownData = JSON.parse(someJsonString);
-     *
      * if (MobileContactInfo.is(unknownData)) {
-     *   // TypeScript now knows this is MobileContactInfo
-     *   console.log(unknownData.name); // ✅ Type-safe access
-     *   console.log(unknownData.phoneNumber.e164Format); // ✅ Type-safe
-     *   console.log(unknownData.mnoId); // ✅ Type-safe
-     *   console.log(unknownData.countryCode); // ✅ Type-safe (from phoneNumber)
-     * } else {
-     *   console.log("Invalid MobileContactInfo structure");
+     *   console.log(unknownData.name); // Type-safe access
      * }
-     *
-     * // Usage in arrays
-     * const contacts = jsonArray.filter(MobileContactInfo.is);
-     * // contacts is now typed as MobileContactInfo[]
      * ```
-     *
-     * @remarks
-     * - Validates both serialized and live objects
-     * - Phone numbers can be provided as strings or PhoneNumber objects
-     * - Uses country-specific MNO validation through MNOUtils
-     * - Returns false for any validation failure (fail-fast approach)
-     * - For non-MNP countries, validates that the MNO matches what would be auto-detected
      */
     static is(obj: unknown): obj is MobileContactInfo;
     /**
      * Validates that all contact information is consistent and correct.
-     * Uses country-specific validation logic through MNOUtils delegation.
-     *
-     * **Validation Checks:**
-     * 1. **Name validation**: Non-empty string
-     * 2. **Phone validation**: Valid phone number structure
-     * 3. **MNO validation**: Valid MNO for the country
-     * 4. **Consistency check**: For non-MNP countries, validates MNO matches auto-detected value from phone prefix
      *
      * @returns {boolean} True if all validations pass, false otherwise
-     *
-     * @example
-     * ```typescript
-     * const contact = new MobileContactInfo("John", phoneNumber, TZMNOId.VODACOM);
-     *
-     * if (contact.validate()) {
-     *   console.log("Contact is valid and ready to use");
-     * } else {
-     *   console.log("Contact has validation issues");
-     *   // Use getValidationDetails() for specific error information
-     * }
-     * ```
-     *
-     * @see {@link getValidationDetails} For detailed validation results with specific errors
      */
     validate(): boolean;
     /**
      * Provides detailed validation results with specific error and warning information.
-     * Uses country-specific validation logic for comprehensive analysis.
-     *
-     * **Validation Categories:**
-     * - **Errors**: Critical issues that make the contact invalid
-     * - **Warnings**: Potential issues that don't prevent usage but indicate inconsistencies
      *
      * @returns {Object} Detailed validation results
-     * @returns {boolean} returns.isValid - True if no errors found
-     * @returns {string[]} returns.errors - Array of error messages for critical issues
-     * @returns {string[]} returns.warnings - Array of warning messages for potential issues
-     *
-     * @example
-     * ```typescript
-     * const contact = new MobileContactInfo("John", phoneNumber);
-     * const validation = contact.getValidationDetails();
-     *
-     * console.log(`Valid: ${validation.isValid}`);
-     *
-     * if (validation.errors.length > 0) {
-     *   console.log("Errors found:");
-     *   validation.errors.forEach(error => console.log(`- ${error}`));
-     * }
-     *
-     * if (validation.warnings.length > 0) {
-     *   console.log("Warnings:");
-     *   validation.warnings.forEach(warning => console.log(`- ${warning}`));
-     * }
-     *
-     * // For non-MNP countries, the MNO is always consistent as it's auto-detected
-     * // Warnings would only appear if there were other potential issues
-     * ```
-     *
-     * @remarks
-     * Uses MNOUtils for country-specific validation logic:
-     * - **Tanzania**: Validates MNO matches auto-detected value from phone number prefix
-     * - **Kenya**: Acknowledges MNP limitations, focuses on MNO validity for country
      */
     getValidationDetails(): {
         isValid: boolean;
         errors: string[];
         warnings: string[];
     };
-    /**
-     * Gets the contact's personal name for display purposes.
-     *
-     * @override
-     * @returns {string} The contact's personal name
-     */
     get accountName(): string;
-    /**
-     * Gets the phone number formatted for display and storage.
-     * Returns the number in e164 format (with + prefix).
-     *
-     * @override
-     * @returns {string} Phone number in e164 format (e.g., "+255712345678")
-     *
-     * @example
-     * ```typescript
-     * const contact = new MobileContactInfo("John", phoneNumber);
-     * console.log(contact.accountNumber); // "+255712345678"
-     * ```
-     */
     get accountNumber(): string;
-    /**
-     * Gets the localized label for the display name field.
-     *
-     * @override
-     * @returns {string} Always returns "Name" for mobile contacts
-     */
     get accountNameLabel(): string;
-    /**
-     * Gets the localized label for the account number field.
-     *
-     * @override
-     * @returns {string} Always returns "Phone Number" for mobile contacts
-     */
     get accountNumberLabel(): string;
-    /**
-     * Gets the localized label for the channel field.
-     *
-     * @override
-     * @returns {string} Always returns "Channel" for mobile contacts
-     */
     get channelLabel(): string;
-    /**
-     * Gets the typed MNO identifier for this mobile contact.
-     * This is the programmatic identifier used for API calls and business logic.
-     *
-     * @returns {MNOId} The MNO identifier (e.g., "VODACOM", "SAFARICOM")
-     *
-     * @example
-     * ```typescript
-     * const contact = new MobileContactInfo("John", tzPhone, TZMNOId.VODACOM);
-     * console.log(contact.channelId); // "VODACOM" (for MNP countries)
-     *
-     * // For non-MNP countries, always returns auto-detected value
-     * const contact2 = new MobileContactInfo("John", tzPhone, TZMNOId.AIRTEL); // AIRTEL ignored
-     * console.log(contact2.channelId); // "VODACOM" (auto-detected from phone prefix)
-     * ```
-     */
     get channelId(): MNOId;
-    /**
-     * Gets the human-readable mobile money service name for display purposes.
-     * Uses MNOUtils to retrieve service information from country-specific implementations.
-     *
-     * **Behavior:**
-     * - Returns the mobile money service name (e.g., "M-Pesa", "Airtel Money")
-     * - Falls back to MNO display name if service name unavailable
-     * - Falls back to MNO ID if no display information available
-     * - For non-MNP countries, always reflects the auto-detected MNO service
-     *
-     * @returns {string} The mobile money service name for display
-     *
-     * @example
-     * ```typescript
-     * const vodacomContact = new MobileContactInfo("John", tzPhone, TZMNOId.VODACOM);
-     * console.log(vodacomContact.channelName); // "M-Pesa"
-     *
-     * const safaricomContact = new MobileContactInfo("Jane", kePhone, KEMNOId.SAFARICOM);
-     * console.log(safaricomContact.channelName); // "M-Pesa"
-     *
-     * // For non-MNP countries, shows auto-detected service regardless of provided MNO
-     * const tzContact = new MobileContactInfo("Bob", tzVodacomPhone, TZMNOId.AIRTEL); // AIRTEL ignored
-     * console.log(tzContact.channelName); // "M-Pesa" (Vodacom's service, auto-detected)
-     * ```
-     *
-     * @remarks
-     * Uses MNOUtils.getMNOById() which delegates to country-specific implementations
-     * for consistent and accurate service name retrieval.
-     */
     get channelName(): string;
+    toJSON(): MobileContactInfoJSON;
+    static fromJSON(json: MobileContactInfoJSON | string): MobileContactInfo | undefined;
+    static fromJSONString(jsonString: string): MobileContactInfo | undefined;
+    static isMobileContactInfoJSON(obj: unknown): obj is MobileContactInfoJSON;
 }
 /**
  * Implementation of BaseContactInfo for bank account contacts.
  * Handles storage, validation, and display of contact details specific to bank transfers.
- * The country code is automatically derived from the Bank object.
- *
- * This class provides comprehensive validation for bank account information including
- * SWIFT code validation, account name verification, and account number format checking.
- *
- * **Key Features:**
- * - SWIFT code validation per country regulations
- * - Account name format validation
- * - Account number format validation (country-specific rules)
- * - Integration with Bank service for institution data
- * - Country code derived from Bank (single source of truth)
  *
  * @extends BaseContactInfo
  * @class BankContactInfo
  *
- * @property {string} accName - The bank account holder's name
- * @property {Bank} bank - The bank institution object with SWIFT code and details
- * @property {string} accNo - The bank account number
- *
  * @example
  * ```typescript
- * // Create bank contact with validation
- * const bank = Bank.from("CORUTZTZ", "TZ"); // CRDB Bank
- * const contact = new BankContactInfo("John Doe", bank, "0150123456789");
- *
- * console.log(contact.channelId); // "CORUTZTZ" (SWIFT code)
- * console.log(contact.channelName); // "CRDB" (bank short name)
- * console.log(contact.accountName); // "John Doe"
- * console.log(contact.accountNumber); // "0150123456789"
- * console.log(contact.countryCode); // "TZ" (from bank)
+ * const bank = Bank.from("CORUTZTZ", "TZ");
+ * const contact = BankContactInfo.from({
+ *   accName: "John Doe",
+ *   bank,
+ *   accNo: "0150123456789"
+ * });
  * ```
- *
- * @throws {ContactInfoError} When validation fails (invalid account name, number, or bank)
  */
 export declare class BankContactInfo extends BaseContactInfo {
     readonly accName: string;
@@ -551,288 +406,83 @@ export declare class BankContactInfo extends BaseContactInfo {
     readonly accNo: string;
     /**
      * Creates a new bank contact with comprehensive validation.
-     * The country code is automatically extracted from the Bank object.
      *
-     * **Validation Process:**
-     * 1. **Country code extraction**: Derived from bank.countryCode
-     * 2. **Account name validation**: Checks format and character requirements
-     * 3. **Account number validation**: Validates format per country banking rules
-     * 4. **Bank validation**: Ensures bank object is valid and contains required data
+     * @deprecated Use {@link BankContactInfo.from} static factory method instead
+     * @param {string} accName - The bank account holder's name
+     * @param {Bank} bank - The bank institution object
+     * @param {string} accNo - The bank account number
+     *
+     * @throws {ContactInfoError} When validation fails
+     */
+    constructor(accName: string, bank: Bank, accNo: string);
+    /**
+     * Creates a BankContactInfo instance from data object.
+     * This is the preferred method for creating instances.
      *
-     * @param {string} accName - The bank account holder's name (must pass BankValidation.validateAccountName)
-     * @param {Bank} bank - The bank institution object (must be valid Bank instance with countryCode)
-     * @param {string} accNo - The bank account number (must pass country-specific validation)
+     * @static
+     * @param {Object} data - The bank contact data
+     * @param {string} data.accName - The account holder's name
+     * @param {Bank} data.bank - The bank institution object
+     * @param {string} data.accNo - The bank account number
      *
-     * @throws {ContactInfoError} When validation fails:
-     * - Invalid account name format
-     * - Invalid account number format for the country
-     * - Invalid or missing bank information
+     * @returns {BankContactInfo | undefined} New instance if successful, undefined if validation fails
      *
      * @example
      * ```typescript
-     * try {
-     *   const bank = Bank.from("CORUTZTZ", "TZ");
-     *   const contact = new BankContactInfo("John Doe", bank, "0150123456789");
-     *   console.log("Bank contact created successfully");
-     *   console.log(`Country: ${contact.countryCode}`); // "TZ" (from bank)
-     * } catch (error) {
-     *   if (error instanceof ContactInfoError) {
-     *     console.log(`Validation failed: ${error.message}`);
-     *   }
-     * }
+     * const bank = Bank.from("CORUTZTZ", "TZ");
+     * const contact = BankContactInfo.from({
+     *   accName: "John Doe",
+     *   bank,
+     *   accNo: "0150123456789"
+     * });
      * ```
      */
-    constructor(accName: string, bank: Bank, accNo: string);
+    static from(data: {
+        accName: string;
+        bank: Bank;
+        accNo: string;
+    }): BankContactInfo | undefined;
     /**
      * Creates a BankContactInfo instance from a ContactDTO object.
-     * Handles SWIFT code validation and bank lookup.
-     * The country code is derived from the SWIFT code.
-     *
-     * **Process:**
-     * 1. Validates DTO type is "Bank"
-     * 2. Extracts SWIFT code from channel field
-     * 3. Derives country code from SWIFT code
-     * 4. Validates SWIFT code format and existence
-     * 5. Looks up bank information using SWIFT code
-     * 6. Delegates to constructor for final validation
      *
      * @static
      * @param {ContactDTO} info - The contact data transfer object
-     * @param {string} info.type - Must be "Bank"
-     * @param {string} info.channel - The SWIFT code for the bank
-     * @param {string} info.displayName - The account holder's name
-     * @param {string} info.accountNo - The bank account number
-     *
      * @returns {BankContactInfo | undefined} New instance if successful, undefined if validation fails
-     *
-     * @example
-     * ```typescript
-     * const contactDTO = {
-     *   type: "Bank",
-     *   channel: "CORUTZTZ", // CRDB Bank SWIFT code
-     *   displayName: "John Doe",
-     *   accountNo: "0150123456789"
-     * };
-     *
-     * const contact = BankContactInfo.fromContactDTO(contactDTO);
-     * if (contact) {
-     *   console.log(`Created bank contact: ${contact.accountName} at ${contact.bank.shortName}`);
-     *   console.log(`Country: ${contact.countryCode}`); // "TZ" (derived from SWIFT)
-     * }
-     * ```
      */
     static fromContactDTO(info: ContactDTO): BankContactInfo | undefined;
     /**
      * Creates a BankContactInfo instance from a PayoutDTO object.
-     * Parses bank information from the payout's msisdn field using "swiftcode:accountno" format.
-     * The country code is derived from the parsed phone number or validated against the SWIFT code.
-     *
-     * **Expected Format:** The msisdn field should contain "SWIFTCODE:ACCOUNTNUMBER"
-     *
-     * **Process:**
-     * 1. Validates country code format in DTO (used as hint/validation)
-     * 2. Splits msisdn field on ":" delimiter
-     * 3. Validates SWIFT code format and existence
-     * 4. Looks up bank information (bank contains country code)
-     * 5. Creates contact with parsed information
      *
      * @static
      * @param {PayoutDTO} info - The payout data transfer object
-     * @param {string} info.msisdn - Bank info in format "SWIFTCODE:ACCOUNTNUMBER"
-     * @param {string} info.countryCode - ISO2 country code (used for validation)
-     * @param {string} info.payeeName - The account holder's name
-     *
      * @returns {BankContactInfo | undefined} New instance if successful, undefined if parsing fails
-     *
-     * @example
-     * ```typescript
-     * const payoutDTO = {
-     *   msisdn: "CORUTZTZ:0150123456789", // SWIFT:Account format
-     *   countryCode: "TZ",
-     *   payeeName: "Jane Smith"
-     * };
-     *
-     * const contact = BankContactInfo.fromPayoutDTO(payoutDTO);
-     * if (contact) {
-     *   console.log(`Payout to: ${contact.accountName}`);
-     *   console.log(`Bank: ${contact.bank.fullName}`);
-     *   console.log(`Account: ${contact.accountNumber}`);
-     *   console.log(`Country: ${contact.countryCode}`); // "TZ" (from bank)
-     * }
-     * ```
-     *
-     * @remarks
-     * Returns undefined if:
-     * - msisdn doesn't contain exactly one ":" separator
-     * - SWIFT code is invalid for the country
-     * - Bank lookup fails
-     * - Any validation error occurs
      */
     static fromPayoutDTO(info: PayoutDTO): BankContactInfo | undefined;
     /**
      * Type guard to validate if an unknown object is a valid BankContactInfo instance.
-     * Performs comprehensive structural and business logic validation.
-     *
-     * **Validation Process:**
-     * 1. **Structural validation**: Checks required properties exist with correct types
-     * 2. **Account name validation**: Uses BankValidation.validateAccountName()
-     * 3. **Account number validation**: Uses country-specific BankValidation.validateAccountNumber()
-     * 4. **Bank validation**: Ensures bank object passes Bank.is() validation
      *
      * @static
      * @param {unknown} obj - The object to validate
      * @returns {obj is BankContactInfo} Type predicate indicating validity
-     *
-     * @example
-     * ```typescript
-     * const unknownData = JSON.parse(bankJsonString);
-     *
-     * if (BankContactInfo.is(unknownData)) {
-     *   // TypeScript now knows this is BankContactInfo
-     *   console.log(unknownData.accName); // ✅ Type-safe access
-     *   console.log(unknownData.bank.fullName); // ✅ Type-safe
-     *   console.log(unknownData.accNo); // ✅ Type-safe
-     *   console.log(unknownData.countryCode); // ✅ Type-safe (from bank)
-     * } else {
-     *   console.log("Invalid BankContactInfo structure");
-     * }
-     *
-     * // Usage in arrays
-     * const bankContacts = jsonArray.filter(BankContactInfo.is);
-     * // bankContacts is now typed as BankContactInfo[]
-     * ```
-     *
-     * @remarks
-     * - Validates both serialized and live objects
-     * - Uses banking industry validation rules through BankValidation
-     * - Ensures bank object contains valid SWIFT code and institution data
-     * - Returns false for any validation failure (fail-fast approach)
      */
     static is(obj: unknown): obj is BankContactInfo;
     validate(): boolean;
-    /**
-     * Gets the bank account holder's name for display purposes.
-     *
-     * @override
-     * @returns {string} The account holder's name
-     */
     get accountName(): string;
-    /**
-     * Gets the bank account number for display and processing.
-     *
-     * @override
-     * @returns {string} The bank account number as provided
-     */
     get accountNumber(): string;
-    /**
-     * Gets the localized label for the display name field.
-     *
-     * @override
-     * @returns {string} Always returns "Acc. Name" for bank contacts
-     */
     get accountNameLabel(): string;
-    /**
-     * Gets the localized label for the account number field.
-     *
-     * @override
-     * @returns {string} Always returns "Bank Acc. No." for bank contacts
-     */
     get accountNumberLabel(): string;
-    /**
-     * Gets the localized label for the channel field.
-     *
-     * @override
-     * @returns {string} Always returns "Bank" for bank contacts
-     */
     get channelLabel(): string;
-    /**
-     * Gets the bank's SWIFT code as the channel identifier.
-     * This is the programmatic identifier used for bank transfers and API calls.
-     *
-     * @returns {BankSwiftCode} The bank's SWIFT/BIC code (e.g., "CORUTZTZ", "KCBLKENX")
-     *
-     * @example
-     * ```typescript
-     * const contact = new BankContactInfo("John", crdBank, "123456789");
-     * console.log(contact.channelId); // "CORUTZTZ"
-     *
-     * // Type-safe usage
-     * if (contact.channelId === "CORUTZTZ") {
-     *   console.log("This is a CRDB Bank account");
-     * }
-     * ```
-     */
     get channelId(): BankSwiftCode;
-    /**
-     * Gets the bank's short name for display purposes.
-     * Provides a human-readable identifier for the banking institution.
-     *
-     * @returns {string} The bank's abbreviated name (e.g., "CRDB", "KCB", "Equity")
-     *
-     * @example
-     * ```typescript
-     * const crdContact = new BankContactInfo("John", crdBank, "123456789");
-     * console.log(crdContact.channelName); // "CRDB"
-     *
-     * const kcbContact = new BankContactInfo("Jane", kcbBank, "987654321");
-     * console.log(kcbContact.channelName); // "KCB"
-     * ```
-     *
-     * @remarks
-     * The short name is maintained by the Bank service and represents
-     * the commonly used abbreviation for the banking institution.
-     */
     get channelName(): string;
+    toJSON(): BankContactInfoJSON;
+    static fromJSON(json: BankContactInfoJSON | string): BankContactInfo | undefined;
+    static fromJSONString(jsonString: string): BankContactInfo | undefined;
+    static isBankContactInfoJSON(obj: unknown): obj is BankContactInfoJSON;
 }
 /**
  * Union type representing either a mobile or bank contact.
- * Used for type-safe handling of contact information throughout the application.
- *
- * This discriminated union allows for:
- * - **Type-safe polymorphism**: Handle different contact types with single interface
- * - **Runtime type discrimination**: Use `contact.type` to determine specific type
- * - **Comprehensive validation**: Each type provides its own validation logic
- * - **Consistent API**: Both types implement BaseContactInfo interface
- * - **Country code access**: Always available via contact.countryCode (derived from domain objects)
  *
  * @typedef {MobileContactInfo | BankContactInfo} ContactInfo
- *
- * @example
- * ```typescript
- * // Type-safe handling of mixed contact types
- * function processContact(contact: ContactInfo) {
- *   console.log(`Processing ${contact.type} contact: ${contact.accountName}`);
- *   console.log(`Channel: ${contact.channelName}`);
- *   console.log(`Country: ${contact.countryCode}`); // Always available
- *
- *   // Type discrimination for specific behavior
- *   if (contact.type === "Mobile") {
- *     // TypeScript knows this is MobileContactInfo
- *     console.log(`MNO: ${contact.mnoId}`);
- *     console.log(`Phone: ${contact.phoneNumber.e164Format}`);
- *   } else {
- *     // TypeScript knows this is BankContactInfo
- *     console.log(`Bank: ${contact.bank.fullName}`);
- *     console.log(`SWIFT: ${contact.bank.swiftCode}`);
- *   }
- * }
- *
- * // Usage with arrays
- * const contacts: ContactInfo[] = [
- *   new MobileContactInfo("John", phoneNumber, TZMNOId.VODACOM),
- *   new BankContactInfo("Jane", bank, "123456789")
- * ];
- *
- * contacts.forEach(processContact);
- *
- * // Type guards work seamlessly
- * const mobileContacts = contacts.filter((c): c is MobileContactInfo => c.type === "Mobile");
- * const bankContacts = contacts.filter((c): c is BankContactInfo => c.type === "Bank");
- * ```
- *
- * @see {@link MobileContactInfo} For mobile money contact implementation
- * @see {@link BankContactInfo} For bank transfer contact implementation
- * @see {@link BaseContactInfo} For common interface and behavior
  */
 export type ContactInfo = MobileContactInfo | BankContactInfo;
 export {};