@temboplus/frontend-core 0.2.1 → 0.2.3

package/esm/src/models/phone_number/global/service.js

@@ -0,0 +1,477 @@
+/**
+ * @fileoverview
+ *
+ * # Global Phone Number Service
+ *
+ * ## Features
+ * 1. Loads and maintains phone number metadata from patterns database
+ * 2. Validates phone numbers against country-specific patterns
+ * 3. Provides utility functions for phone number operations
+ * 4. Follows singleton pattern for efficient resource usage
+ */
+import { Country } from "../../country/country.js";
+import { PhoneNumber } from "./phone_number.js";
+import phonePatterns from "../../../data/phone_patterns.js";
+import { PhoneNumberFormat } from "../format.js";
+/**
+ * Phone number pattern type
+ */
+export var PhoneNumberType;
+(function (PhoneNumberType) {
+    PhoneNumberType["LANDLINE"] = "landline";
+    PhoneNumberType["MOBILE"] = "mobile";
+    PhoneNumberType["TOLL_FREE"] = "toll_free";
+    PhoneNumberType["PREMIUM_RATE"] = "premium_rate";
+    PhoneNumberType["SHARED_COST"] = "shared_cost";
+    PhoneNumberType["EMERGENCY"] = "emergency";
+    PhoneNumberType["SPECIAL_SERVICES"] = "special_services";
+    PhoneNumberType["VOIP"] = "voip";
+    PhoneNumberType["PERSONAL"] = "personal";
+    PhoneNumberType["UNKNOWN"] = "unknown";
+})(PhoneNumberType || (PhoneNumberType = {}));
+/**
+ * Error thrown when a phone number has an ambiguous country due to shared dial code
+ */
+export class SharedDialCodeError extends Error {
+    /**
+     * Creates a new SharedDialCodeError
+     *
+     * @param dialCode - The shared dial code
+     * @param countries - Countries that share this dial code
+     */
+    constructor(dialCode, countries) {
+        const message = `Dial code +${dialCode} is shared by multiple countries: ${countries.join(", ")}. Please use 'fromWithCountry' with a specific country.`;
+        super(message);
+        /** The dial code that's shared */
+        Object.defineProperty(this, "dialCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /** List of country codes that share this dial code */
+        Object.defineProperty(this, "countries", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "SharedDialCodeError";
+        this.dialCode = dialCode;
+        this.countries = countries;
+    }
+}
+/**
+ * Service for managing global phone number operations
+ */
+export class GlobalPhoneNumberService {
+    /**
+     * Private constructor to enforce singleton pattern
+     */
+    constructor() {
+        Object.defineProperty(this, "countryMetadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "sharedCountryCodes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "initialized", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+    }
+    /**
+     * Gets the singleton instance of GlobalPhoneNumberService
+     * Creates the instance if it doesn't exist
+     *
+     * @returns {GlobalPhoneNumberService} The singleton instance
+     */
+    static getInstance() {
+        if (!GlobalPhoneNumberService.instance) {
+            GlobalPhoneNumberService.instance = new GlobalPhoneNumberService();
+            GlobalPhoneNumberService.instance.initialize();
+        }
+        return GlobalPhoneNumberService.instance;
+    }
+    /**
+     * Initializes the service with phone patterns data
+     * Should be called once when the service is first used
+     */
+    initialize() {
+        try {
+            if (this.initialized)
+                return;
+            // Parse the phone patterns data
+            const data = JSON.parse(JSON.stringify(phonePatterns));
+            // Extract shared country codes
+            this.sharedCountryCodes = data._shared_country_codes || {};
+            const countries = Object.entries(data)
+                .filter(([key]) => !key.startsWith("_"))
+                .reduce((result, [key, value]) => {
+                result[key] = value;
+                return result;
+            }, {});
+            this.countryMetadata = countries;
+            this.initialized = true;
+        }
+        catch (error) {
+            console.error("Failed to initialize GlobalPhoneNumberService:", error);
+        }
+    }
+    /**
+     * Gets the metadata for a specific country
+     *
+     * @param {string} countryCode - The ISO country code
+     * @returns {CountryMetadata | undefined} The country metadata or undefined if not found
+     */
+    getCountryMetadata(countryCode) {
+        return this.countryMetadata[countryCode];
+    }
+    /**
+     * Gets all country metadata
+     *
+     * @returns {CountryMetadataMap} All country metadata
+     */
+    getAllCountryMetadata() {
+        return this.countryMetadata;
+    }
+    /**
+     * Gets all the countries that share a specific dial code
+     *
+     * @param {string | number} dialCode - The dial code to check
+     * @returns {string[]} Array of ISO country codes that share this dial code
+     */
+    getCountriesWithDialCode(dialCode) {
+        const dialCodeStr = dialCode.toString();
+        return this.sharedCountryCodes[dialCodeStr] || [];
+    }
+    /**
+     * Checks if a dial code is shared between multiple countries
+     *
+     * @param {string | number} dialCode - The dial code to check
+     * @returns {boolean} True if the dial code is shared, false otherwise
+     */
+    isSharedDialCode(dialCode) {
+        const dialCodeStr = dialCode.toString();
+        const countries = this.sharedCountryCodes[dialCodeStr];
+        return countries !== undefined && countries.length > 1;
+    }
+    /**
+     * Finds the country code associated with a given dial code
+     *
+     * @param dialCode - The dial code to look up
+     * @returns The country code or undefined if not found
+     */
+    getCountryForDialCode(dialCode) {
+        for (const [countryCode, metadata] of Object.entries(this.countryMetadata)) {
+            if (metadata.code.toString() === dialCode) {
+                return countryCode;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Extracts dial code information from a phone number
+     *
+     * @param phoneNumber - The phone number in international format (with +)
+     * @returns Dial code information or undefined if not found
+     */
+    extractDialCode(phoneNumber) {
+        const cleaned = this.cleanPhoneNumber(phoneNumber);
+        if (!cleaned.startsWith("+"))
+            return undefined;
+        const numberWithoutPlus = cleaned.substring(1);
+        // Try to find the dial code by checking prefixes of increasing length
+        for (let i = 3; i >= 1; i--) {
+            if (numberWithoutPlus.length <= i)
+                continue;
+            const dialCode = numberWithoutPlus.substring(0, i);
+            // Check if any country has this dial code
+            let countryFound = false;
+            for (const [_, metadata] of Object.entries(this.countryMetadata)) {
+                if (metadata.code.toString() === dialCode) {
+                    countryFound = true;
+                    break;
+                }
+            }
+            if (countryFound) {
+                const nationalNumber = numberWithoutPlus.substring(dialCode.length);
+                const isShared = this.isSharedDialCode(dialCode);
+                const possibleCountries = isShared
+                    ? this.sharedCountryCodes[dialCode]
+                    : [this.getCountryForDialCode(dialCode) ?? ""];
+                return {
+                    dialCode,
+                    isShared,
+                    nationalNumber,
+                    possibleCountries,
+                };
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Gets the countries that might be associated with a phone number
+     *
+     * @param {string} phoneNumber - The phone number in international format
+     * @returns {Country[]} Array of possible countries for this phone number
+     */
+    getPossibleCountries(phoneNumber) {
+        const cleanedNumber = this.cleanPhoneNumber(phoneNumber);
+        if (!cleanedNumber.startsWith("+"))
+            return [];
+        const dialCodeInfo = this.extractDialCode(cleanedNumber);
+        if (!dialCodeInfo)
+            return [];
+        const possibleCountries = [];
+        for (const countryCode of dialCodeInfo.possibleCountries) {
+            const country = Country.fromCode(countryCode);
+            if (country)
+                possibleCountries.push(country);
+        }
+        return possibleCountries;
+    }
+    /**
+     * Determines the most likely type of a phone number
+     *
+     * @param {string} countryCode - ISO country code
+     * @param {string} nationalNumber - The national number to check
+     * @returns {PhoneNumberType} The type of the phone number
+     */
+    getNumberType(countryCode, nationalNumber) {
+        if (!countryCode || !nationalNumber) {
+            return PhoneNumberType.UNKNOWN;
+        }
+        const metadata = this.countryMetadata[countryCode];
+        if (!metadata || !metadata.patterns) {
+            return PhoneNumberType.UNKNOWN;
+        }
+        // Verify that required patterns exist
+        if (!metadata.patterns.landline || !metadata.patterns.mobile) {
+            console.error(`Country ${countryCode} is missing required patterns for landline or mobile`);
+            return PhoneNumberType.UNKNOWN;
+        }
+        // Check each type of pattern
+        for (const [type, pattern] of Object.entries(metadata.patterns)) {
+            if (!pattern)
+                continue;
+            try {
+                const regex = new RegExp(pattern);
+                if (regex.test(nationalNumber)) {
+                    return type;
+                }
+            }
+            catch (e) {
+                console.error(`Invalid regex pattern for ${countryCode}.${type}:`, e);
+            }
+        }
+        return PhoneNumberType.UNKNOWN;
+    }
+    /**
+     * Validates a phone number against country-specific patterns
+     *
+     * @param {string} countryCode - ISO country code
+     * @param {string} nationalNumber - The national number to validate
+     * @returns {boolean} True if the phone number is valid, false otherwise
+     */
+    validatePattern(countryCode, nationalNumber) {
+        if (!countryCode || !nationalNumber) {
+            return false;
+        }
+        const metadata = this.countryMetadata[countryCode];
+        if (!metadata || !metadata.patterns) {
+            return false;
+        }
+        // Verify that required patterns exist
+        if (!metadata.patterns.landline || !metadata.patterns.mobile) {
+            console.error(`Country ${countryCode} is missing required patterns for landline or mobile`);
+            return false;
+        }
+        // Check if the number matches any of the patterns for this country
+        for (const [type, pattern] of Object.entries(metadata.patterns)) {
+            if (!pattern)
+                continue;
+            try {
+                const regex = new RegExp(pattern);
+                if (regex.test(nationalNumber)) {
+                    return true;
+                }
+            }
+            catch (e) {
+                console.error(`Invalid regex pattern for ${countryCode}.${type}:`, e);
+            }
+        }
+        return false;
+    }
+    /**
+     * Formats a phone number according to the country's formatting rules
+     *
+     * @param {string} phoneNumber - The phone number to format
+     * @param {PhoneNumberFormat} format - The desired format
+     * @returns {string} The formatted phone number
+     */
+    formatNumber(phoneNumber, format = PhoneNumberFormat.INTERNATIONAL) {
+        const phone = PhoneNumber.from(phoneNumber);
+        if (!phone)
+            return phoneNumber;
+        return phone.getWithFormat(format);
+    }
+    /**
+     * Creates a PhoneNumber from an international format string
+     *
+     * @param {string} phoneNumber - The phone number in international format
+     * @returns {PhoneNumber | undefined} The parsed phone number or undefined if invalid
+     */
+    parsePhoneNumber(phoneNumber) {
+        return PhoneNumber.from(phoneNumber);
+    }
+    /**
+     * Creates a PhoneNumber from a phone number with explicit country
+     *
+     * @param {string} phoneNumber - The phone number in any format
+     * @param {Country | string} country - The country or country code
+     * @returns {PhoneNumber | undefined} The parsed phone number or undefined if invalid
+     */
+    parsePhoneNumberWithCountry(phoneNumber, country) {
+        const countryObj = typeof country === "string"
+            ? Country.fromCode(country)
+            : country;
+        if (!countryObj)
+            return undefined;
+        return PhoneNumber.fromWithCountry(phoneNumber, countryObj);
+    }
+    /**
+     * Extracts the information needed for dialing from one country to another
+     *
+     * @param {string} fromCountry - ISO code of the country dialing from
+     * @param {PhoneNumber} phoneNumber - The phone number to dial
+     * @returns {string} The appropriately formatted dialing string
+     */
+    getDialingString(fromCountry, phoneNumber) {
+        if (!fromCountry || !phoneNumber || !PhoneNumber.is(phoneNumber)) {
+            return "";
+        }
+        // Simple implementation that always uses international format
+        // A production version would handle local dialing formats
+        return phoneNumber.getWithFormat(PhoneNumberFormat.INTERNATIONAL);
+    }
+    /**
+     * Cleans a phone number by removing all non-digit characters except the leading plus
+     *
+     * @param {string} phoneNumber - The phone number to clean
+     * @returns {string} The cleaned phone number
+     */
+    cleanPhoneNumber(phoneNumber) {
+        if (!phoneNumber)
+            return "";
+        // Preserve the leading +
+        const hasPlus = phoneNumber.trim().startsWith("+");
+        // Remove all non-digit characters
+        const digitsOnly = phoneNumber.replace(/\D/g, "");
+        // Add the plus back if it was present
+        return hasPlus ? `+${digitsOnly}` : digitsOnly;
+    }
+    /**
+     * Extracts the country and national number from an international phone number
+     *
+     * @param {string} phoneNumber - The phone number in international format
+     * @returns {[Country | undefined, string]} The country and national number
+     */
+    extractParts(phoneNumber) {
+        const cleaned = this.cleanPhoneNumber(phoneNumber);
+        if (!cleaned.startsWith("+"))
+            return [undefined, cleaned];
+        const dialCodeInfo = this.extractDialCode(cleaned);
+        if (!dialCodeInfo)
+            return [undefined, cleaned.substring(1)];
+        if (dialCodeInfo.isShared) {
+            // For shared dial codes, we return undefined for the country
+            return [undefined, dialCodeInfo.nationalNumber];
+        }
+        else {
+            // For non-shared dial codes, we return the country
+            const countryCode = dialCodeInfo.possibleCountries[0];
+            const country = countryCode ? Country.fromCode(countryCode) : undefined;
+            return [country, dialCodeInfo.nationalNumber];
+        }
+    }
+    /**
+     * Gets a list of commonly used examples of valid phone numbers for a country
+     *
+     * @param {string} countryCode - The ISO country code
+     * @returns {string[]} Array of example phone numbers
+     */
+    getExampleNumbers(countryCode) {
+        const metadata = this.countryMetadata[countryCode];
+        if (!metadata)
+            return [];
+        const dialCode = metadata.code;
+        const examples = [];
+        // Since landline and mobile patterns are required, we can always generate examples
+        // Landline example
+        examples.push(`+${dialCode}${this.generateExampleFromPattern(metadata.patterns.landline)}`);
+        // Mobile example
+        examples.push(`+${dialCode}${this.generateExampleFromPattern(metadata.patterns.mobile)}`);
+        return examples;
+    }
+    /**
+     * Generates an example phone number that would match a given pattern
+     * This is a simple implementation that handles basic patterns
+     *
+     * @param pattern - The regex pattern
+     * @returns A string that would match the pattern
+     */
+    generateExampleFromPattern(pattern) {
+        // Very basic implementation - a real one would be more sophisticated
+        // but this handles simple patterns like "^[2-8]\\d{7}$"
+        // Find basic digit patterns like \d{7}
+        const digitMatch = pattern.match(/\\d\{(\d+)\}/);
+        const digitCount = digitMatch ? parseInt(digitMatch[1]) : 8;
+        // Find range patterns like [2-8]
+        const rangeMatch = pattern.match(/\[(\d)-(\d)\]/);
+        const firstDigit = rangeMatch ? rangeMatch[1] : "5";
+        // Combine them
+        return `${firstDigit}${"0".repeat(digitCount - 1)}`;
+    }
+    /**
+     * Checks if a phone number is valid for a specific country
+     *
+     * @param {string} phoneNumber - The phone number to validate
+     * @param {string} countryCode - The ISO country code
+     * @returns {boolean} True if the phone number is valid for the country, false otherwise
+     */
+    isValidForCountry(phoneNumber, countryCode) {
+        const country = Country.fromCode(countryCode);
+        if (!country)
+            return false;
+        const phone = PhoneNumber.fromWithCountry(phoneNumber, country);
+        return phone !== undefined;
+    }
+    /**
+     * Checks if a given dial code exists in our database
+     *
+     * @param dialCode - The dial code to check
+     * @returns True if the dial code exists, false otherwise
+     */
+    hasDialCode(dialCode) {
+        // Check if it's a shared dial code
+        if (this.sharedCountryCodes[dialCode]?.length > 0) {
+            return true;
+        }
+        // Check if any country has this dial code
+        for (const metadata of Object.values(this.countryMetadata)) {
+            if (metadata.code.toString() === dialCode) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

package/esm/src/models/phone_number/global/service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.test.d.ts","sourceRoot":"","sources":["../../../../../src/src/models/phone_number/global/service.test.ts"],"names":[],"mappings":""}

package/esm/src/models/phone_number/index.d.ts

@@ -1,4 +1,6 @@
-export * from "./antd_validator.js";
-export * from "./phone_number.js";
-export * from "./network_operator.js";
+export * from "./tz/antd_validator.js";
+export * from "./tz/phone_number.js";
+export * from "./tz/network_operator.js";
+export * from "./global/phone_number.js";
+export * from "./format.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/src/models/phone_number/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/models/phone_number/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/models/phone_number/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,aAAa,CAAA"}

package/esm/src/models/phone_number/index.js

@@ -1,3 +1,5 @@
-export * from "./antd_validator.js";
-export * from "./phone_number.js";
-export * from "./network_operator.js";
+export * from "./tz/antd_validator.js";
+export * from "./tz/phone_number.js";
+export * from "./tz/network_operator.js";
+export * from "./global/phone_number.js";
+export * from "./format.js";

package/esm/src/models/phone_number/{antd_validator.d.ts → tz/antd_validator.d.ts}

@@ -1,5 +1,5 @@
 import type { RuleObject } from "antd/es/form";
-import { PhoneNumber } from "./phone_number.js";
+import { TZPhoneNumber } from "./phone_number.js";
 /**
  * Validates a Tanzanian phone number according to specified format rules.
  * This validator is designed for Ant Design Form components and performs the following validations:
@@ -73,5 +73,5 @@ import { PhoneNumber } from "./phone_number.js";
  * $                   -> End of string
  */
 export declare const TZ_PHONE_NUMBER_REGEX: RegExp;
-export declare const PHONENUMBER_VALIDATOR: (rule: RuleObject, value: string | null | undefined) => Promise<PhoneNumber | undefined>;
+export declare const PHONENUMBER_VALIDATOR: (rule: RuleObject, value: string | null | undefined) => Promise<TZPhoneNumber | undefined>;
 //# sourceMappingURL=antd_validator.d.ts.map

package/esm/src/models/phone_number/tz/antd_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"antd_validator.d.ts","sourceRoot":"","sources":["../../../../../src/src/models/phone_number/tz/antd_validator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEG;AACH,eAAO,MAAM,qBAAqB,QACkF,CAAC;AAErH,eAAO,MAAM,qBAAqB,SAC1B,UAAU,SACT,MAAM,GAAG,IAAI,GAAG,SAAS,KAC/B,OAAO,CAAC,aAAa,GAAG,SAAS,CAiBnC,CAAC"}

package/esm/src/models/phone_number/{antd_validator.js → tz/antd_validator.js}

@@ -1,4 +1,4 @@
-import { PhoneNumber } from "./phone_number.js";
+import { TZPhoneNumber } from "./phone_number.js";
 /**
  * Validates a Tanzanian phone number according to specified format rules.
  * This validator is designed for Ant Design Form components and performs the following validations:
@@ -83,7 +83,7 @@ export const PHONENUMBER_VALIDATOR = (rule, value) => {
         // If field is not required and empty, validation passes
         return Promise.resolve(undefined);
     }
-    const phone = PhoneNumber.from(phoneString);
+    const phone = TZPhoneNumber.from(phoneString);
     if (phone)
         return Promise.resolve(phone);
     return Promise.reject(new Error("Invalid phone number format."));

package/esm/src/models/phone_number/tz/antdvalidator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"antdvalidator.test.d.ts","sourceRoot":"","sources":["../../../../../src/src/models/phone_number/tz/antdvalidator.test.ts"],"names":[],"mappings":""}

package/esm/src/models/phone_number/tz/network_operator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"network_operator.d.ts","sourceRoot":"","sources":["../../../../../src/src/models/phone_number/tz/network_operator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,eAAe;IACzB,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,IAAI,SAAS;IACb,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,iDAAiD;IACjD,EAAE,EAAE,eAAe,CAAC;IAEpB,+DAA+D;IAC/D,oBAAoB,EAAE,MAAM,EAAE,CAAC;IAE/B,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IAEpB,wDAAwD;IACxD,kBAAkB,EAAE,MAAM,CAAC;IAE3B,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,eAAe,EACf,mBAAmB,CA8BpB,CAAC"}

package/{script/src/models/phone_number → esm/src/models/phone_number/tz}/phone_number.d.ts

@@ -23,49 +23,66 @@
  *    - Tigo: 65, 67, etc.
  *    - Halotel: 62, etc.
  *
+ * 4. Phone numbers can be formatted in the following ways:
+ *    - International format: "+255 XXX XXX XXX"
+ *    - National format: "0XXX XXX XXX"
+ *    - Compact format: "XXXXXXXXX"
+ *    - RFC3966 format: "tel:+255XXXXXXXXX"
+ *
  * ## Solution
- * The PhoneNumber class provides:
+ * The TZPhoneNumber class provides:
  * 1. Parsing and validation of different input formats
  * 2. Standardized storage in compact format
  * 3. Formatting options for display and API use
  * 4. Network operator identification
  */
 import { type NetworkOperatorInfo } from "./network_operator.js";
-/**
- * Enumeration for various mobile number formats.
- * @enum {string}
- */
-export declare enum MobileNumberFormat {
-    s255 = "255",// Mobile numbers prefixed with 255
-    sp255 = "+255",// Mobile numbers prefixed with +255
-    s0 = "0",// Mobile numbers prefixed with 0
-    none = ""
-}
+import { PhoneNumberFormat } from "../format.js";
 /**
  * Represents a TZ phone number
  */
-export declare class PhoneNumber {
+export declare class TZPhoneNumber {
     /**
      * Stores the phone number in a compact format excluding country code and the initial '0'.
      */
-    compactNumber: string;
+    private _compactNumber;
     /**
-     * Constructs a new `PhoneNumber` instance.
+     * Private constructor to prevent direct instantiation.
+     * Use TZPhoneNumber.from() instead.
      *
      * @param compactNumber - The phone number in a compact format (e.g., "712345678").
      */
-    constructor(compactNumber: string);
+    private constructor();
+    /**
+     * Gets the compact number (national number without formatting)
+     */
+    get compactNumber(): string;
     /**
-     * Formats the compact phone number with the specified `MobileNumberFormat`.
+     * Formats the phone number according to the specified format
      *
-     * @param format - The desired phone number format (e.g., `+255` or `255`).
-     * @returns The phone number formatted as a string.
+     * @param format - The desired format from GlobalPhoneNumberFormat
+     * @returns The formatted phone number string
+     */
+    getWithFormat(format: PhoneNumberFormat): string;
+    /**
+     * Formats the phone number in international format with spaces
+     * Format: +255 XXX XXX XXX
+     */
+    private formatInternational;
+    /**
+     * Formats the phone number in national format with spaces
+     * Format: 0XXX XXX XXX
+     */
+    private formatNational;
+    /**
+     * Formats the phone number according to RFC3966
+     * Format: tel:+255XXXXXXXXX
      */
-    getNumberWithFormat(format: MobileNumberFormat): string;
+    private formatRFC3966;
     /**
-     * Returns the formatted label of the phone number using the `s255` format.
+     * Returns the formatted label of the phone number using the international format.
      *
-     * @returns The phone number label in `255` format.
+     * @returns The phone number label in international format.
      */
     get label(): string;
     /**
@@ -75,12 +92,12 @@ export declare class PhoneNumber {
      */
     get networkOperator(): NetworkOperatorInfo;
     /**
-     * Creates a `PhoneNumber` instance from a given string.
+     * Creates a `TZPhoneNumber` instance from a given string.
      *
      * @param s - The input phone number string in various formats (e.g., "+255712345678", "0712345678").
-     * @returns A `PhoneNumber` instance if valid, otherwise `undefined`.
+     * @returns A `TZPhoneNumber` instance if valid, otherwise `undefined`.
      */
-    static from(s: string): PhoneNumber | undefined;
+    static from(input: string): TZPhoneNumber | undefined;
     /**
      * Checks if a string can be constructed into a valid phone number object.
      * @param {string | undefined} input - The string to validate as a phone number.
@@ -89,16 +106,16 @@ export declare class PhoneNumber {
      */
     static canConstruct(input?: string | null): boolean;
     /**
-     * Checks if an unknown value contains valid data to construct a PhoneNumber instance.
+     * Checks if an unknown value contains valid data to construct a TZPhoneNumber instance.
      * Validates the structural integrity of the phone number object.
      *
      * @param {unknown} obj - The value to validate.
-     * @returns {obj is PhoneNumber} Type predicate indicating if the value has a valid phone number structure.
+     * @returns {obj is TZPhoneNumber} Type predicate indicating if the value has a valid phone number structure.
      *
      * @example
      * const maybePhone = JSON.parse(someData);
-     * if (PhoneNumber.is(maybePhone)) {
-     *   // maybePhone is typed as PhoneNumber
+     * if (TZPhoneNumber.is(maybePhone)) {
+     *   // maybePhone is typed as TZPhoneNumber
      *   console.log(maybePhone.label);
      * }
      *
@@ -108,7 +125,7 @@ export declare class PhoneNumber {
      * - compactNumber is a 9-digit string
      * - Prefix matches a valid network operator
      */
-    static is(obj: unknown): obj is PhoneNumber;
+    static is(obj: unknown): obj is TZPhoneNumber;
     /**
      * Checks the validity of the phone number data
      * @returns true if the phone number information is available and valid