@temboplus/frontend-core 0.2.20-beta.0 → 0.2.20-beta.2

package/dist/models/amount/amount.d.ts

@@ -1,9 +1,38 @@
+import { z } from "zod";
 import { CurrencyCode } from "../currency/index.js";
 /**
  * Regular expression for validating amount strings
  * Supports both positive and negative amounts with optional comma separators and decimals
  */
 declare const AMOUNT_REGEX: RegExp;
+/**
+ * Zod schema for Amount JSON serialization
+ * This schema validates the JSON representation of an Amount instance
+ */
+export declare const AmountJSONSchema: z.ZodObject<{
+    /** The numeric value of the amount (can be positive, negative, or zero) */
+    value: z.ZodNumber;
+    /** The formatted text representation of the amount */
+    text: z.ZodString;
+    /** The ISO currency code */
+    currencyCode: z.ZodString;
+    /** Version for future compatibility */
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    value: number;
+    text: string;
+    currencyCode: string;
+}, {
+    value: number;
+    text: string;
+    currencyCode: string;
+    version?: string | undefined;
+}>;
+/**
+ * Infer the AmountJSON type from the schema
+ */
+export type AmountJSON = z.infer<typeof AmountJSONSchema>;
 /**
  * Represents a monetary amount with currency information
  *
@@ -563,76 +592,25 @@ declare class Amount {
      */
     getWholeValue(): number;
     /**
-     * Serializes the Amount instance to a JSON-compatible object
-     *
-     * This method creates a plain object representation that can be safely
-     * serialized to JSON without losing any essential data.
-     *
-     * @returns {AmountJson} A plain object containing all necessary Amount data
-     *
-     * @example
-     * ```typescript
-     * const amount = Amount.from(-1234.56, 'USD');
-     * const json = amount.toJson();
-     * console.log(json);
-     * // {
-     * //   value: -1234.56,
-     * //   text: "1,234.56",
-     * //   currencyCode: "USD",
-     * //   version: "1.0"
-     * // }
-     *
-     * // Can be safely stringified
-     * const jsonString = JSON.stringify(json);
-     * ```
+   * Serializes the Amount instance to a JSON-compatible object
+   */
+    toJSON(): AmountJSON;
+    /**
+     * Serializes the Amount instance to a JSON string
      */
-    toJson(): AmountJson;
+    toJSONString(): string;
     /**
-     * Creates an Amount instance from a JSON-compatible object
-     *
-     * This static method reconstructs an Amount instance from data that was
-     * previously serialized using toJson(). It validates the input data and
-     * ensures the resulting Amount is valid.
-     *
-     * @param {AmountJson | string} json - Either an AmountJson object or a JSON string
-     * @returns {Amount | undefined} An Amount instance if valid, undefined otherwise
-     *
-     * @example
-     * ```typescript
-     * // From object
-     * const jsonData = {
-     *   value: -1234.56,
-     *   text: "1,234.56",
-     *   currencyCode: "USD",
-     *   version: "1.0"
-     * };
-     * const amount = Amount.fromJson(jsonData);
-     *
-     * // From JSON string
-     * const jsonString = '{"value":-1234.56,"text":"1,234.56","currencyCode":"USD","version":"1.0"}';
-     * const amount2 = Amount.fromJson(jsonString);
-     *
-     * // Both create equivalent Amount instances
-     * console.log(amount?.label); // "-$1,234.56"
-     * console.log(amount2?.label); // "-$1,234.56"
-     * ```
+     * Creates an Amount instance from a JSON-compatible object or string
      */
-    static fromJson(json: AmountJson | string): Amount | undefined;
+    static fromJSON(json: AmountJSON | string): Amount | undefined;
     /**
-     * Type guard to check if an object is a valid AmountJson
-     *
-     * @param obj - The object to validate
-     * @returns True if the object conforms to AmountJson structure
-     *
-     * @example
-     * ```typescript
-     * const data = { value: 100, text: "100.00", currencyCode: "USD" };
-     * if (Amount.isAmountJson(data)) {
-     *   const amount = Amount.fromJson(data);
-     * }
-     * ```
+     * Creates an Amount instance from a JSON string
+     */
+    static fromJSONString(jsonString: string): Amount | undefined;
+    /**
+     * Type guard to check if an object is a valid AmountJSON using Zod validation
      */
-    static isAmountJson(obj: unknown): obj is AmountJson;
+    static isAmountJSON(obj: unknown): obj is AmountJSON;
     /**
      * Returns the sum of multiple amounts
      *

package/dist/models/bank/bank.d.ts

@@ -1,5 +1,11 @@
 import { ISO2CountryCode } from "../country/country.types.js";
 import type { BankSwiftCode, KEBankSwiftCode, TZBankSwiftCode } from "./bank.types.js";
+import { z } from "zod";
+import { BankJSONSchema } from "./bank.schema.js";
+/**
+ * Infer the BankJSON type from the schema
+ */
+export type BankJSON = z.infer<typeof BankJSONSchema>;
 export declare class Bank {
     /**
      * The full registered name of the bank.
@@ -32,30 +38,6 @@ export declare class Bank {
      */
     toString(): string;
     static from(swiftCode: BankSwiftCode, countryCode: ISO2CountryCode): Bank;
-    /**
-     * Creates a Bank instance from a JSON string.
-     *
-     * The JSON should contain swiftCode and countryCode fields.
-     * The bank data is then looked up from the bank service to ensure validity.
-     *
-     * @static
-     * @param {string} jsonString - JSON string containing bank data
-     * @returns {Bank | undefined} A new Bank instance if successful, undefined if parsing fails
-     *
-     * @example
-     * ```typescript
-     * const jsonString = '{"swiftCode":"CORUTZTZ","countryCode":"TZ"}';
-     * const bank = Bank.fromJSON(jsonString);
-     * if (bank) {
-     *   console.log(bank.fullName); // "CRDB BANK PLC"
-     * }
-     *
-     * // Also works with full bank data
-     * const fullJson = '{"fullName":"CRDB BANK PLC","shortName":"CRDB","swiftCode":"CORUTZTZ","countryCode":"TZ"}';
-     * const bank2 = Bank.fromJSON(fullJson);
-     * ```
-     */
-    static fromJSON(jsonString: string): Bank | undefined;
     /**
      * Converts the Bank instance to a plain JavaScript object.
      * Suitable for serialization or data transfer.
@@ -85,27 +67,6 @@ export declare class Bank {
         swiftCode: TZBankSwiftCode | KEBankSwiftCode;
         countryCode: ISO2CountryCode;
     };
-    /**
-     * Serializes the Bank instance to a JSON string.
-     *
-     * @returns {string} JSON string representation of the bank
-     *
-     * @example
-     * ```typescript
-     * const bank = Bank.from("CORUTZTZ", "TZ");
-     * const jsonString = bank.toJSON();
-     * console.log(jsonString);
-     * // '{"fullName":"CRDB BANK PLC","shortName":"CRDB","swiftCode":"CORUTZTZ","countryCode":"TZ"}'
-     *
-     * // Store or transmit
-     * localStorage.setItem('selectedBank', jsonString);
-     *
-     * // Later, retrieve and reconstruct
-     * const stored = localStorage.getItem('selectedBank');
-     * const reconstructed = Bank.fromJSON(stored);
-     * ```
-     */
-    toJSON(): string;
     /**
      * Static method to determine if an unknown object is a valid Bank object.
      *
@@ -116,6 +77,26 @@ export declare class Bank {
      * @returns {obj is Bank} - Returns true if the object is a valid Bank, false otherwise.
      */
     static is(obj: unknown): obj is Bank;
+    /**
+   * Serializes the Bank instance to a JSON-compatible object
+   */
+    toJSON(): BankJSON;
+    /**
+     * Serializes the Bank instance to a JSON string
+     */
+    toJSONString(): string;
+    /**
+     * Creates a Bank instance from a JSON-compatible object or string
+     */
+    static fromJSON(json: BankJSON | string): Bank | undefined;
+    /**
+     * Creates a Bank instance from a JSON string
+     */
+    static fromJSONString(jsonString: string): Bank | undefined;
+    /**
+     * Type guard to check if an object is a valid BankJSON using Zod validation
+     */
+    static isBankJSON(obj: unknown): obj is BankJSON;
 }
 /**
  * Service for managing bank data, validation, and instance creation

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

@@ -1,3 +1,23 @@
 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.ZodObject<{
+    /** The SWIFT/BIC code for the bank's head office */
+    swiftCode: 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;
+    swiftCode: string;
+    countryCode: string;
+}, {
+    swiftCode: string;
+    countryCode: string;
+    version?: string | undefined;
+}>;

package/dist/models/country/country.d.ts

@@ -27,6 +27,12 @@
 import { Currency } from "@models/currency/currency.js";
 import { CurrencyCode } from "@models/currency/currency.types.js";
 import { ISO2CountryCode, ISO3CountryCode, CountryCode } from "./country.types.js";
+import { z } from "zod";
+import { CountryJSONSchema } from "./country.schema.js";
+/**
+ * Infer the CountryJSON type from the schema
+ */
+export type CountryJSON = z.infer<typeof CountryJSONSchema>;
 /**
  * Enum for continents
  */
@@ -716,6 +722,26 @@ export declare class Country {
      * @returns Type predicate indicating if the value is a valid Country
      */
     static is(obj: unknown): obj is Country;
+    /**
+     * Serializes the Country instance to a JSON-compatible object
+     */
+    toJSON(): CountryJSON;
+    /**
+     * Serializes the Country instance to a JSON string
+     */
+    toJSONString(): string;
+    /**
+     * Creates a Country instance from a JSON-compatible object or string
+     */
+    static fromJSON(json: CountryJSON | string): Country | undefined;
+    /**
+     * Creates a Country instance from a JSON string
+     */
+    static fromJSONString(jsonString: string): Country | undefined;
+    /**
+     * Type guard to check if an object is a valid CountryJSON using Zod validation
+     */
+    static isCountryJSON(obj: unknown): obj is CountryJSON;
 }
 /**
  * Service for managing country data.

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

@@ -1,4 +1,20 @@
 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.
  *
@@ -43,4 +59,15 @@ export declare const ISO3CountryCodeSchema: z.ZodEffects<z.ZodString, string, st
  *   console.error("Invalid country code");
  * }
  */
-export declare const CountryCodeSchema: z.ZodUnion<[z.ZodEffects<z.ZodString, string, string>, z.ZodEffects<z.ZodString, string, string>]>;
+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/dist/models/currency/currency.d.ts

@@ -27,6 +27,12 @@
  * dependencies are best managed in a unified module.
  */
 import type { CurrencyCode } from "./currency.types.js";
+import { z } from "zod";
+import { CurrencyJSONSchema } from "./currency.schema.js";
+/**
+ * Infer the CurrencyJSON type from the schema
+ */
+export type CurrencyJSON = z.infer<typeof CurrencyJSONSchema>;
 /**
  * Represents a currency with essential details.
  * @class Currency
@@ -367,6 +373,26 @@ export declare class Currency {
      * @returns Type predicate indicating if the value is a valid Currency
      */
     static is(obj: unknown): obj is Currency;
+    /**
+     * Serializes the Currency instance to a JSON-compatible object
+     */
+    toJSON(): CurrencyJSON;
+    /**
+     * Serializes the Currency instance to a JSON string
+     */
+    toJSONString(): string;
+    /**
+     * Creates a Currency instance from a JSON-compatible object or string
+     */
+    static fromJSON(json: CurrencyJSON | string): Currency | undefined;
+    /**
+     * Creates a Currency instance from a JSON string
+     */
+    static fromJSONString(jsonString: string): Currency | undefined;
+    /**
+     * Type guard to check if an object is a valid CurrencyJSON using Zod validation
+     */
+    static isCurrencyJSON(obj: unknown): obj is CurrencyJSON;
 }
 /**
  * Service for managing currency data.

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

@@ -6,3 +6,19 @@ import { z } from "zod";
  * 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/dist/models/phone-number/phone-number.d.ts

@@ -3,6 +3,33 @@ import type { PhoneNumber as LibPhoneNumberInstance } from "libphonenumber-js";
 import { MNOInfo } from "./mno/mno.types.js";
 import { PhoneNumberService, ParsedPhoneNumber } from "./phone-number.service.js";
 import { PhoneNumberContract, PhoneNumberFormat, PhoneNumberType, PhoneNumberParseOptions } from "./phone-number.types.js";
+import { z } from "zod";
+/**
+ * Zod schema for PhoneNumber JSON serialization
+ * This schema validates the JSON representation of a PhoneNumber instance
+ *
+ * E.164 format validation rules:
+ * - Starts with '+'
+ * - Followed by country code (1-3 digits, first digit 1-9)
+ * - Total length: 8-16 characters (including '+')
+ * - Contains only digits after '+'
+ */
+export declare const PhoneNumberJSONSchema: z.ZodObject<{
+    /** The phone number in E.164 format */
+    e164Format: z.ZodString;
+    /** Version for future compatibility */
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    e164Format: string;
+}, {
+    e164Format: string;
+    version?: string | undefined;
+}>;
+/**
+ * Infer the PhoneNumberJSON type from the schema
+ */
+export type PhoneNumberJSON = z.infer<typeof PhoneNumberJSONSchema>;
 /**
  * Represents a generic international phone number, validated using libphonenumber-js
  * via the PhoneNumberService. Implements the common PhoneNumberContract interface.
@@ -75,4 +102,34 @@ export declare class PhoneNumber implements PhoneNumberContract {
      * Robust type guard checking structure and validatability.
      */
     static is(obj: unknown): obj is PhoneNumberContract;
+    /**
+     * Serializes the PhoneNumber instance to a JSON-compatible object
+     *
+     * This method creates a minimal object representation. Only the E.164 format
+     * is stored as everything else (country code, compact number, number type,
+     * and MNO info) can be reconstructed from it.
+     */
+    toJSON(): PhoneNumberJSON;
+    /**
+     * Serializes the PhoneNumber instance to a JSON string
+     */
+    toJSONString(): string;
+    /**
+     * Creates a PhoneNumber instance from a JSON-compatible object or string
+     *
+     * This static method reconstructs a PhoneNumber instance from data that was
+     * previously serialized using toJSON(). It uses PhoneNumberFactory to get
+     * the appropriate instance (generic or country-specific like TZMobileNumber).
+     * All properties including country code, compact number, MNO info, and number
+     * type are automatically reconstructed from the E.164 format.
+     */
+    static fromJSON(json: PhoneNumberJSON | string): PhoneNumber | undefined;
+    /**
+     * Creates a PhoneNumber instance from a JSON string
+     */
+    static fromJSONString(jsonString: string): PhoneNumber | undefined;
+    /**
+     * Type guard to check if an object is a valid PhoneNumberJSON using Zod validation
+     */
+    static isPhoneNumberJSON(obj: unknown): obj is PhoneNumberJSON;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@temboplus/frontend-core",
-  "version": "0.2.20-beta.0",
+  "version": "0.2.20-beta.2",
   "description": "A JavaScript/TypeScript package providing common utilities and logic shared across front-end TemboPlus projects.",
   "author": "Okello Gerald",
   "license": "MIT",