@temboplus/afloat 0.1.77-beta.8 → 0.1.77-beta.9

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

@@ -1,5 +1,75 @@
 import { ContactDTO, ContactType } from "@/modules/contact/contact.dtos.js";
 import { ContactInfo } from "./contact-info.model.js";
+import { z } from "zod";
+/**
+ * Zod schema for Contact JSON serialization
+ * This schema validates the JSON representation of a Contact instance
+ *
+ * The Contact JSON format wraps the ContactDTO structure for consistency
+ * and future extensibility (e.g., adding metadata, version info)
+ */
+export declare const ContactJSONSchema: z.ZodObject<{
+    /** The complete contact data transfer object */
+    data: z.ZodObject<{
+        id: z.ZodString;
+        profileId: z.ZodString;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    } & {
+        displayName: z.ZodString;
+        accountNo: z.ZodString;
+        channel: z.ZodString;
+        type: z.ZodNativeEnum<typeof ContactType>;
+    }, "strip", z.ZodTypeAny, {
+        type: ContactType;
+        id: string;
+        displayName: string;
+        accountNo: string;
+        profileId: string;
+        createdAt: string;
+        updatedAt: string;
+        channel: string;
+    }, {
+        type: ContactType;
+        id: string;
+        displayName: string;
+        accountNo: string;
+        profileId: string;
+        createdAt: string;
+        updatedAt: string;
+        channel: string;
+    }>;
+    /** Version for future compatibility */
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    version: string;
+    data: {
+        type: ContactType;
+        id: string;
+        displayName: string;
+        accountNo: string;
+        profileId: string;
+        createdAt: string;
+        updatedAt: string;
+        channel: string;
+    };
+}, {
+    data: {
+        type: ContactType;
+        id: string;
+        displayName: string;
+        accountNo: string;
+        profileId: string;
+        createdAt: string;
+        updatedAt: string;
+        channel: string;
+    };
+    version?: string | undefined;
+}>;
+/**
+ * Infer the ContactJSON type from the schema
+ */
+export type ContactJSON = z.infer<typeof ContactJSONSchema>;
 /**
  * Contact class that wraps the Zod schema and provides additional functionality.
  * Represents a contact entity with validation and type-safe access to contact information.
@@ -199,23 +269,6 @@ export declare class Contact {
      * ```
      */
     static createSafe(data: ContactDTO): Contact | null;
-    /**
-     * Creates a Contact instance from a JSON string.
-     *
-     * @static
-     * @param {string} jsonString - JSON string containing contact data
-     * @returns {Contact | undefined} Contact instance or undefined if parsing/validation fails
-     *
-     * @example
-     * ```typescript
-     * const jsonString = '{"id":"123","displayName":"John Doe",...}';
-     * const contact = Contact.fromJSON(jsonString);
-     * if (contact) {
-     *   console.log(contact.displayName);
-     * }
-     * ```
-     */
-    static fromJSON(jsonString: string): Contact | undefined;
     /**
      * Checks if an unknown value contains valid data to construct a Contact instance.
      * This is useful when validating raw data structures before instantiation.
@@ -268,29 +321,121 @@ export declare class Contact {
      */
     static is(obj: unknown): obj is Contact;
     /**
-     * Converts the Contact instance to a plain object.
+     * Serializes the Contact instance to a JSON-compatible object
      *
-     * @returns {ContactDTO} Plain object representation of the contact
+     * This method creates a structured representation suitable for storage or transmission.
+     * The serialized format includes all contact data and a version identifier for
+     * future compatibility.
+     *
+     * @returns {ContactJSON} JSON-compatible object representation
      *
      * @example
      * ```typescript
      * const contact = Contact.from(contactData);
-     * const plainObject = contact?.toObject();
-     * // Use plainObject for API calls or storage
+     * const json = contact.toJSON();
+     * // { data: { id: "123", displayName: "John", ... }, version: "1.0" }
+     *
+     * // Store in localStorage
+     * localStorage.setItem('contact', JSON.stringify(json));
      * ```
      */
-    toObject(): ContactDTO;
+    toJSON(): ContactJSON;
     /**
-     * Converts the Contact instance to a JSON string.
+     * Serializes the Contact instance to a JSON string
      *
-     * @returns {string} JSON string representation of the contact
+     * Convenience method that combines toJSON() with JSON.stringify()
+     *
+     * @returns {string} JSON string representation
      *
      * @example
      * ```typescript
      * const contact = Contact.from(contactData);
-     * const jsonString = contact?.toJSON();
+     * const jsonString = contact.toJSONString();
      * localStorage.setItem('contact', jsonString);
      * ```
      */
-    toJSON(): string;
+    toJSONString(): string;
+    /**
+     * Creates a Contact instance from a JSON-compatible object or string
+     *
+     * This static method reconstructs a Contact instance from data that was
+     * previously serialized using toJSON(). It performs comprehensive validation
+     * to ensure data integrity.
+     *
+     * **Validation Process:**
+     * 1. Parses JSON string if provided
+     * 2. Validates structure using Zod schema
+     * 3. Extracts and validates ContactDTO data
+     * 4. Constructs Contact instance with validated data
+     *
+     * @static
+     * @param {ContactJSON | string} json - JSON object or string containing contact data
+     * @returns {Contact | undefined} New Contact instance if successful, undefined if parsing/validation fails
+     *
+     * @example
+     * ```typescript
+     * // From JSON object
+     * const json = { data: { id: "123", displayName: "John", ... }, version: "1.0" };
+     * const contact = Contact.fromJSON(json);
+     *
+     * // From JSON string
+     * const jsonString = localStorage.getItem('contact');
+     * const contact = Contact.fromJSON(jsonString);
+     *
+     * // With error handling
+     * const contact = Contact.fromJSON(jsonString);
+     * if (contact) {
+     *   console.log("Contact restored:", contact.displayName);
+     * } else {
+     *   console.error("Failed to restore contact from JSON");
+     * }
+     * ```
+     */
+    static fromJSON(json: ContactJSON | string): Contact | undefined;
+    /**
+     * Creates a Contact instance from a JSON string
+     *
+     * Convenience method that delegates to fromJSON()
+     *
+     * @static
+     * @param {string} jsonString - JSON string containing contact data
+     * @returns {Contact | undefined} New Contact instance if successful, undefined if parsing fails
+     *
+     * @example
+     * ```typescript
+     * const jsonString = '{"data":{"id":"123","displayName":"John",...},"version":"1.0"}';
+     * const contact = Contact.fromJSONString(jsonString);
+     * ```
+     */
+    static fromJSONString(jsonString: string): Contact | undefined;
+    /**
+     * Type guard to check if an object is a valid ContactJSON using Zod validation
+     *
+     * This method validates the structure of a JSON object to ensure it contains
+     * all required fields and meets the ContactJSON schema requirements.
+     *
+     * @static
+     * @param {unknown} obj - The object to validate
+     * @returns {obj is ContactJSON} Type predicate indicating if the object is valid ContactJSON
+     *
+     * @example
+     * ```typescript
+     * const data = JSON.parse(jsonString);
+     *
+     * if (Contact.isContactJSON(data)) {
+     *   // TypeScript now knows data is ContactJSON
+     *   const contact = Contact.fromJSON(data);
+     * } else {
+     *   console.error("Invalid ContactJSON structure");
+     * }
+     * ```
+     *
+     * @remarks
+     * Use this method when:
+     * - Validating JSON data before deserialization
+     * - Implementing type guards in conditional logic
+     * - Checking API responses before processing
+     * - Validating cached data integrity
+     */
+    static isContactJSON(obj: unknown): obj is ContactJSON;
 }

package/dist/modules/login/login.model.d.ts

@@ -1,10 +1,43 @@
 import { LogInDTO } from "./login.dtos.js";
-export type LogInJson = {
+import { z } from "zod";
+/**
+ * Zod schema for LogIn JSON serialization
+ * This schema validates the JSON representation of a LogIn instance
+ */
+export declare const LogInJSONSchema: z.ZodObject<{
+    id: z.ZodString;
+    profileId: z.ZodString;
+    name: z.ZodString;
+    identity: z.ZodString;
+    type: z.ZodString;
+    roleId: z.ZodString;
+    isActive: z.ZodBoolean;
+    isArchived: z.ZodBoolean;
+    resetPassword: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    access: z.ZodArray<z.ZodString, "many">;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    name: string;
     id: string;
+    version: string;
     profileId: string;
-    name: string;
     identity: string;
+    roleId: string;
+    isActive: boolean;
+    isArchived: boolean;
+    resetPassword: boolean;
+    createdAt: string;
+    updatedAt: string;
+    access: string[];
+}, {
     type: string;
+    name: string;
+    id: string;
+    profileId: string;
+    identity: string;
     roleId: string;
     isActive: boolean;
     isArchived: boolean;
@@ -12,7 +45,12 @@ export type LogInJson = {
     createdAt: string;
     updatedAt: string;
     access: string[];
-};
+    version?: string | undefined;
+}>;
+/**
+ * Infer the LogInJSON type from the schema
+ */
+export type LogInJSON = z.infer<typeof LogInJSONSchema>;
 /**
  * Represents the authenticated user's identity and account information.
  *
@@ -63,18 +101,6 @@ export declare class LogIn {
      * ```
      */
     static from(dto: LogInDTO): LogIn;
-    /**
-     * Creates a LogIn instance from a JSON string.
-     *
-     * @param json - JSON string containing login data
-     * @returns A new LogIn instance, or undefined if parsing failed
-     *
-     * @example
-     * ```typescript
-     * const logIn = LogIn.fromJson('{"id":"abc","name":"John",...}');
-     * ```
-     */
-    static fromJson(json: string): LogIn | undefined;
     /**
      * Gets the user's unique identifier.
      */
@@ -124,15 +150,19 @@ export declare class LogIn {
      */
     get access(): ReadonlyArray<string>;
     /**
-     * Converts the LogIn instance to a plain object.
-     *
-     * @returns A plain object representation
+    * Serializes the LogIn instance to a JSON-compatible object
+    */
+    toJSON(): LogInJSON;
+    /**
+     * Serializes the LogIn instance to a JSON string
      */
-    toObject(): LogInJson;
+    toJSONString(): string;
     /**
-     * Converts the LogIn instance to a JSON string.
-     *
-     * @returns A JSON string representation
+     * Creates a LogIn instance from a JSON-compatible object or string
+     */
+    static fromJSON(json: LogInJSON | string): LogIn | undefined;
+    /**
+     * Type guard using Zod schema validation
      */
-    toJson(): string;
+    static isLogInJSON(obj: unknown): obj is LogInJSON;
 }

package/dist/modules/payout/payout.model.d.ts

@@ -1,6 +1,119 @@
 import { PayoutDTO, PayoutStatus, PayoutApprovalStatus, PayoutAuthorizer } from "@/modules/payout/payout.dtos.js";
 import { Amount } from "@temboplus/frontend-core";
 import { ContactInfo } from "../contact/contact-info.model.js";
+import z from "zod";
+/**
+ * Zod schema for Payout JSON serialization
+ * This mirrors the PayoutDTO structure but is specifically for JSON serialization
+ */
+export declare const PayoutJSONSchema: z.ZodObject<{
+    id: z.ZodString;
+    profileId: z.ZodString;
+    payeeName: z.ZodString;
+    channel: z.ZodString;
+    msisdn: z.ZodString;
+    amount: z.ZodNumber;
+    currencyCode: z.ZodString;
+    countryCode: z.ZodString;
+    description: z.ZodString;
+    notes: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodNativeEnum<typeof PayoutStatus>;
+    statusMessage: z.ZodString;
+    partnerReference: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    actionedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    approvalStatus: z.ZodOptional<z.ZodNullable<z.ZodNativeEnum<typeof PayoutApprovalStatus>>>;
+    createdBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        identity: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        identity: string;
+    }, {
+        name: string;
+        id: string;
+        identity: string;
+    }>>>;
+    actionedBy: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        identity: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        id: string;
+        identity: string;
+    }, {
+        name: string;
+        id: string;
+        identity: string;
+    }>>>;
+    version: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    status: PayoutStatus;
+    id: string;
+    version: string;
+    profileId: string;
+    createdAt: string;
+    updatedAt: string;
+    description: string;
+    channel: string;
+    countryCode: string;
+    currencyCode: string;
+    msisdn: string;
+    amount: number;
+    payeeName: string;
+    statusMessage: string;
+    notes?: string | null | undefined;
+    partnerReference?: string | null | undefined;
+    actionedAt?: string | null | undefined;
+    approvalStatus?: PayoutApprovalStatus | null | undefined;
+    createdBy?: {
+        name: string;
+        id: string;
+        identity: string;
+    } | null | undefined;
+    actionedBy?: {
+        name: string;
+        id: string;
+        identity: string;
+    } | null | undefined;
+}, {
+    status: PayoutStatus;
+    id: string;
+    profileId: string;
+    createdAt: string;
+    updatedAt: string;
+    description: string;
+    channel: string;
+    countryCode: string;
+    currencyCode: string;
+    msisdn: string;
+    amount: number;
+    payeeName: string;
+    statusMessage: string;
+    version?: string | undefined;
+    notes?: string | null | undefined;
+    partnerReference?: string | null | undefined;
+    actionedAt?: string | null | undefined;
+    approvalStatus?: PayoutApprovalStatus | null | undefined;
+    createdBy?: {
+        name: string;
+        id: string;
+        identity: string;
+    } | null | undefined;
+    actionedBy?: {
+        name: string;
+        id: string;
+        identity: string;
+    } | null | undefined;
+}>;
+/**
+ * Infer the PayoutJSON type from the schema
+ */
+export type PayoutJSON = z.infer<typeof PayoutJSONSchema>;
 /**
  * Payout class that wraps the Zod schema and provides additional functionality
  */
@@ -133,7 +246,134 @@ export declare class Payout {
      */
     static is(obj: unknown): obj is Payout;
     /**
-     * Converts Payout instance to a plain object
+   * Serializes the Payout instance to a JSON-compatible object
+   *
+   * Converts all Date objects to ISO strings for proper JSON serialization.
+   * The resulting object can be safely stringified and stored or transmitted.
+   *
+   * @returns {PayoutJSON} A plain object containing all payout data
+   *
+   * @example
+   * ```typescript
+   * const payout = Payout.create(payoutData);
+   * const json = payout.toJSON();
+   * // {
+   * //   id: "payout-123",
+   * //   amount: 50000,
+   * //   currencyCode: "TZS",
+   * //   createdAt: "2024-01-15T10:30:00.000Z",
+   * //   ...
+   * // }
+   * ```
+   */
+    toJSON(): PayoutJSON;
+    /**
+     * Serializes the Payout instance to a JSON string
+     *
+     * @returns {string} JSON string representation of the payout
+     *
+     * @example
+     * ```typescript
+     * const payout = Payout.create(payoutData);
+     * const jsonString = payout.toJSONString();
+     *
+     * // Store in localStorage
+     * localStorage.setItem('pendingPayout', jsonString);
+     *
+     * // Or send to server
+     * await fetch('/api/cache-payout', {
+     *   method: 'POST',
+     *   body: jsonString
+     * });
+     * ```
+     */
+    toJSONString(): string;
+    /**
+     * Creates a Payout instance from a JSON-compatible object or string
+     *
+     * This method reconstructs a Payout instance from data that was previously
+     * serialized using toJSON(). It validates the input data using Zod schema
+     * and converts ISO date strings back to Date objects.
+     *
+     * @param {PayoutJSON | string} json - Either a PayoutJSON object or a JSON string
+     * @returns {Payout | undefined} A Payout instance if valid, undefined otherwise
+     *
+     * @example
+     * ```typescript
+     * // From localStorage
+     * const stored = localStorage.getItem('pendingPayout');
+     * const payout = Payout.fromJSON(stored!);
+     *
+     * if (payout) {
+     *   console.log(payout.amount.label); // "TSh 50,000.00"
+     *   console.log(payout.status); // "PENDING"
+     * }
+     *
+     * // From object
+     * const payoutJson = {
+     *   id: "payout-123",
+     *   amount: 50000,
+     *   currencyCode: "TZS",
+     *   createdAt: "2024-01-15T10:30:00.000Z",
+     *   ...
+     * };
+     * const payout = Payout.fromJSON(payoutJson);
+     * ```
+     */
+    static fromJSON(json: PayoutJSON | string): Payout | undefined;
+    /**
+     * Type guard using Zod schema validation
+     *
+     * Checks if an unknown value conforms to the PayoutJSON structure
+     * without attempting to create a Payout instance.
+     *
+     * @param {unknown} obj - The object to validate
+     * @returns {boolean} True if the object is a valid PayoutJSON
+     *
+     * @example
+     * ```typescript
+     * const data = JSON.parse(localStorage.getItem('payout'));
+     *
+     * if (Payout.isPayoutJSON(data)) {
+     *   const payout = Payout.fromJSON(data);
+     *   // TypeScript knows data is PayoutJSON here
+     * }
+     * ```
+     */
+    static isPayoutJSON(obj: unknown): obj is PayoutJSON;
+    /**
+     * Creates multiple Payout instances from a JSON array
+     *
+     * @param {PayoutJSON[] | string} jsonArray - Array of PayoutJSON objects or JSON string
+     * @returns {Payout[]} Array of Payout instances (invalid items are filtered out)
+     *
+     * @example
+     * ```typescript
+     * // From API response
+     * const response = await fetch('/api/payouts');
+     * const jsonArray = await response.json();
+     * const payouts = Payout.fromJSONArray(jsonArray);
+     *
+     * // From stored array
+     * const stored = localStorage.getItem('recentPayouts');
+     * const payouts = Payout.fromJSONArray(stored!);
+     * ```
+     */
+    static fromJSONArray(jsonArray: PayoutJSON[] | string): Payout[];
+    /**
+     * Serializes an array of Payout instances to JSON
+     *
+     * @param {Payout[]} payouts - Array of Payout instances to serialize
+     * @returns {PayoutJSON[]} Array of PayoutJSON objects
+     *
+     * @example
+     * ```typescript
+     * const payouts = [payout1, payout2, payout3];
+     * const jsonArray = Payout.toJSONArray(payouts);
+     *
+     * // Store or transmit
+     * localStorage.setItem('recentPayouts', JSON.stringify(jsonArray));
+     * ```
      */
-    toJSON(): PayoutDTO;
+    static toJSONArray(payouts: Payout[]): PayoutJSON[];
 }