@temboplus/afloat 0.1.77-beta.9 → 0.1.79

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

@@ -1,441 +0,0 @@
-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.
- *
- * @class Contact
- *
- * @example
- * ```typescript
- * // Preferred: Use static factory methods
- * const contact = Contact.from(contactData);
- *
- * // From JSON
- * const jsonContact = Contact.fromJSON(jsonString);
- *
- * // Type-safe access
- * if (contact) {
- *   console.log(contact.displayName);
- *   console.log(contact.info?.channelName);
- * }
- * ```
- */
-export declare class Contact {
-    private readonly data;
-    /**
-     * Private constructor - use static factory methods to create instances.
-     *
-     * @deprecated Use {@link Contact.from} or other static factory methods instead
-     * @private
-     * @param {ContactDTO} data - Validated contact data
-     */
-    private constructor();
-    /**
-     * Unique identifier for the contact.
-     *
-     * @returns {string} The contact's unique ID
-     */
-    get id(): string;
-    /**
-     * Profile identifier associated with this contact.
-     *
-     * @returns {string} The profile ID
-     */
-    get profileId(): string;
-    /**
-     * Display name of the contact.
-     *
-     * @returns {string} The contact's display name
-     */
-    get displayName(): string;
-    /**
-     * Type of contact (Bank or Mobile).
-     *
-     * @returns {ContactType} The contact type
-     */
-    get type(): ContactType;
-    /**
-     * Creation timestamp of the contact.
-     *
-     * @returns {Date} The creation date
-     */
-    get createdAt(): Date;
-    /**
-     * Update timestamp of the contact.
-     *
-     * @returns {Date} The last update date
-     */
-    get updatedAt(): Date;
-    /**
-     * Detailed contact information based on contact type.
-     *
-     * @returns {ContactInfo | undefined} Contact information object:
-     * - MobileContactInfo for mobile money contacts
-     * - BankContactInfo for bank contacts
-     * - undefined if contact information cannot be constructed
-     *
-     * @remarks
-     * For mobile contacts, constructs from phone number.
-     * For bank contacts, constructs from SWIFT code and account number.
-     */
-    get info(): ContactInfo | undefined;
-    /**
-     * Account number for the contact.
-     *
-     * @returns {string} Account number:
-     * - For valid contacts, returns formatted account number from ContactInfo
-     * - For invalid contacts, falls back to raw account number
-     */
-    get accNo(): string;
-    /**
-     * Account name for the contact.
-     * Always returns the display name.
-     *
-     * @returns {string} The account name
-     */
-    get accName(): string;
-    /**
-     * Label for the account number field based on contact type.
-     *
-     * @returns {string} Appropriate label:
-     * - "Phone Number" for mobile contacts
-     * - "Bank Account Number" for bank contacts
-     * - "Account Number" as fallback
-     */
-    get accNoLabel(): string;
-    /**
-     * Label for the channel field based on contact type.
-     *
-     * @returns {string} Appropriate label:
-     * - "Channel" for mobile contacts
-     * - "Bank" for bank contacts
-     * - "Channel" as fallback
-     */
-    get channelLabel(): string;
-    /**
-     * Label for the account name field based on contact type.
-     *
-     * @returns {string} Appropriate label:
-     * - "Full Name" for mobile contacts
-     * - "Bank Account Name" for bank contacts
-     * - "Display Name" as fallback
-     */
-    get accNameLabel(): string;
-    /**
-     * Human-readable channel name for the contact.
-     *
-     * @returns {string} The channel name (e.g., "M-Pesa", "CRDB") or empty string
-     */
-    get channelName(): string;
-    /**
-     * Creates a Contact instance from raw data.
-     * This is the preferred method for creating Contact instances.
-     *
-     * @static
-     * @param {ContactDTO} data - Raw contact data to validate and wrap
-     * @returns {Contact | undefined} Contact instance or undefined if validation fails
-     *
-     * @example
-     * ```typescript
-     * const contact = Contact.from({
-     *   id: "123",
-     *   profileId: "profile-456",
-     *   displayName: "John Doe",
-     *   type: "Mobile",
-     *   accountNo: "+255712345678",
-     *   channel: "VODACOM",
-     *   createdAt: "2024-01-01T00:00:00Z",
-     *   updatedAt: "2024-01-01T00:00:00Z"
-     * });
-     * ```
-     */
-    static from(data: ContactDTO): Contact | undefined;
-    /**
-     * Creates a Contact instance from raw data, throwing on validation failure.
-     *
-     * @static
-     * @param {ContactDTO} data - Raw contact data to validate and wrap
-     * @returns {Contact} Contact instance
-     * @throws {ZodError} If validation fails
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   const contact = Contact.create(contactData);
-     * } catch (error) {
-     *   console.error("Validation failed:", error);
-     * }
-     * ```
-     */
-    static create(data: ContactDTO): Contact;
-    /**
-     * Creates multiple Contact instances from an array of raw data.
-     *
-     * @static
-     * @param {ContactDTO[]} dataArray - Array of contact data
-     * @returns {Contact[]} Array of Contact instances
-     * @throws {ZodError} If validation fails for any item
-     *
-     * @example
-     * ```typescript
-     * const contacts = Contact.createMany([contactData1, contactData2]);
-     * ```
-     */
-    static createMany(dataArray: ContactDTO[]): Contact[];
-    /**
-     * Creates a Contact instance from raw data without throwing.
-     *
-     * @static
-     * @param {ContactDTO} data - Raw contact data
-     * @returns {Contact | null} Contact instance or null if validation fails
-     *
-     * @example
-     * ```typescript
-     * const contact = Contact.createSafe(contactData);
-     * if (contact) {
-     *   console.log("Contact created successfully");
-     * }
-     * ```
-     */
-    static createSafe(data: ContactDTO): Contact | null;
-    /**
-     * Checks if an unknown value contains valid data to construct a Contact instance.
-     * This is useful when validating raw data structures before instantiation.
-     *
-     * @static
-     * @param {unknown} obj - The value containing potential contact data
-     * @returns {obj is Contact} Type predicate indicating if a Contact can be constructed
-     *
-     * @example
-     * ```typescript
-     * const rawData = await fetchFromAPI();
-     * if (Contact.canConstruct(rawData)) {
-     *   const contact = Contact.create(rawData);
-     *   console.log(contact.displayName);
-     * }
-     * ```
-     *
-     * @remarks
-     * This method performs strict validation against the {@link ContactDTO} schema.
-     */
-    static canConstruct(obj: unknown): obj is Contact;
-    /**
-     * Validates if an unknown value is a Contact instance.
-     * This is a runtime type guard that ensures proper object structure and data validity.
-     *
-     * @static
-     * @param {unknown} obj - The value to validate
-     * @returns {obj is Contact} Type predicate indicating if the value is a valid Contact
-     *
-     * @example
-     * ```typescript
-     * const maybeContact = getContactFromCache();
-     * if (Contact.is(maybeContact)) {
-     *   console.log(maybeContact.displayName); // Type-safe
-     * }
-     * ```
-     *
-     * @remarks
-     * This method performs a complete structural validation:
-     * 1. Checks if the value is an object
-     * 2. Verifies presence of internal data property
-     * 3. Validates the data against ContactDTO schema
-     * 4. Ensures the object is a proper Contact instance
-     *
-     * Use this method when:
-     * - Validating cached Contact instances
-     * - Checking serialized Contact objects
-     * - Verifying API responses
-     * - Type narrowing in conditional blocks
-     */
-    static is(obj: unknown): obj is Contact;
-    /**
-     * Serializes the Contact instance to a JSON-compatible object
-     *
-     * 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 json = contact.toJSON();
-     * // { data: { id: "123", displayName: "John", ... }, version: "1.0" }
-     *
-     * // Store in localStorage
-     * localStorage.setItem('contact', JSON.stringify(json));
-     * ```
-     */
-    toJSON(): ContactJSON;
-    /**
-     * Serializes the Contact instance to a JSON string
-     *
-     * Convenience method that combines toJSON() with JSON.stringify()
-     *
-     * @returns {string} JSON string representation
-     *
-     * @example
-     * ```typescript
-     * const contact = Contact.from(contactData);
-     * const jsonString = contact.toJSONString();
-     * localStorage.setItem('contact', jsonString);
-     * ```
-     */
-    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/contact/contact.repository.d.ts

@@ -1,116 +0,0 @@
-import { BaseRepository } from "@/lib/api/base-repository.js";
-import { ContactInfo } from "@/modules/contact/contact-info.model.js";
-import { Contact } from "@/modules/contact/contact.model.js";
-import { contract } from "./contact.api-contract.js";
-/**
- * Repository class for managing Contact data through API interactions.
- * Handles contact creation, updates, deletion, and retrieval operations.
- *
- * This repository handles pure API communication without permission checking.
- * Permission validation should be handled at the service layer or route handlers.
- *
- * @extends {BaseRepository<typeof contract>}
- *
- * @example
- * ```typescript
- * const repo = new ContactRepository({ token: userToken });
- * const contacts = await repo.getAll();
- * ```
- */
-export declare class ContactRepository extends BaseRepository<typeof contract> {
-    /**
-     * Creates an instance of ContactRepository using the contact contract.
-     *
-     * @param options - Optional configuration
-     * @param options.token - Authentication token for API calls
-     * @param options.root - Custom API root URL
-     *
-     * @example
-     * ```typescript
-     * const repo = new ContactRepository({
-     *   token: "user-auth-token",
-     *   root: "https://api-staging.afloat.money/v1"
-     * });
-     * ```
-     */
-    constructor(options?: {
-        token?: string;
-        root?: string;
-    });
-    /**
-     * Creates a new contact record.
-     *
-     * @param info - The data required to create a new contact
-     * @returns Promise that resolves to the newly created contact
-     * @throws {APIError} If the creation operation fails
-     *
-     * @example
-     * ```typescript
-     * const newContact = await repo.create({
-     *   name: "John Doe",
-     *   email: "john@example.com",
-     *   phone: "+1234567890"
-     * });
-     * ```
-     */
-    create(info: ContactInfo): Promise<Contact>;
-    /**
-     * Updates an existing contact record by ID.
-     *
-     * @param id - The unique identifier of the contact to edit
-     * @param info - The data to update the contact with
-     * @returns Promise that resolves to the updated contact
-     * @throws {APIError} If the update operation fails
-     *
-     * @example
-     * ```typescript
-     * const updatedContact = await repo.edit("contact-id", {
-     *   name: "Jane Doe",
-     *   email: "jane@example.com"
-     * });
-     * ```
-     */
-    edit(id: string, info: ContactInfo): Promise<Contact>;
-    /**
-     * Deletes a contact record by ID.
-     *
-     * @param id - The unique identifier of the contact to remove
-     * @returns Promise that resolves when the deletion is complete
-     * @throws {APIError} If the deletion operation fails
-     *
-     * @example
-     * ```typescript
-     * await repo.remove("contact-id");
-     * console.log("Contact deleted successfully");
-     * ```
-     */
-    remove(id: string): Promise<void>;
-    /**
-     * Retrieves all contacts.
-     * Results are ordered in descending order by creation date by default.
-     *
-     * @returns Promise that resolves to an array of contacts
-     * @throws {APIError} If the fetch operation fails
-     *
-     * @example
-     * ```typescript
-     * const contacts = await repo.getAll();
-     * contacts.forEach(contact => console.log(`Contact: ${contact.name}`));
-     * ```
-     */
-    getAll(): Promise<Contact[]>;
-    /**
-     * Retrieves a contact by its unique identifier.
-     *
-     * @param id - The unique identifier of the contact to retrieve
-     * @returns Promise that resolves to the requested contact
-     * @throws {APIError} If the contact is not found or fetch operation fails
-     *
-     * @example
-     * ```typescript
-     * const contact = await repo.getByID("contact-id");
-     * console.log(`Contact: ${contact.name}, Email: ${contact.email}`);
-     * ```
-     */
-    getByID(id: string): Promise<Contact>;
-}

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

@@ -1,4 +0,0 @@
-export * from "./contact.repository.js";
-export * from "./contact.dtos.js";
-export * from "./contact-info.model.js";
-export * from "./contact.model.js";

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

@@ -1,4 +0,0 @@
-export * from "./login.dtos.js";
-export * from "./login.model.js";
-export * from "./login.repository.js";
-export * from "./permission.type.js";

package/dist/modules/login/login.api-contract.d.ts

@@ -1,51 +0,0 @@
-/**
- * Identity API contract
- */
-export declare const identityContract: {
-    getUserCredentials: {
-        method: "GET";
-        path: "/me";
-        responses: {
-            200: import("zod").ZodObject<{
-                id: import("zod").ZodString;
-                profileId: import("zod").ZodString;
-                name: import("zod").ZodString;
-                identity: import("zod").ZodString;
-                type: import("zod").ZodString;
-                roleId: import("zod").ZodString;
-                isActive: import("zod").ZodBoolean;
-                isArchived: import("zod").ZodBoolean;
-                resetPassword: import("zod").ZodBoolean;
-                createdAt: import("zod").ZodString;
-                updatedAt: import("zod").ZodString;
-                access: import("zod").ZodArray<import("zod").ZodString, "many">;
-            }, "strip", import("zod").ZodTypeAny, {
-                type: string;
-                name: string;
-                id: string;
-                profileId: 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;
-                resetPassword: boolean;
-                createdAt: string;
-                updatedAt: string;
-                access: string[];
-            }>;
-        };
-    };
-};

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

@@ -1,85 +0,0 @@
-import z from "zod";
-declare const LogInDTOSchema: 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">;
-}, "strip", z.ZodTypeAny, {
-    type: string;
-    name: string;
-    id: string;
-    profileId: 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;
-    resetPassword: boolean;
-    createdAt: string;
-    updatedAt: string;
-    access: string[];
-}>;
-export declare const LogInSchemas: {
-    loginDTO: 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">;
-    }, "strip", z.ZodTypeAny, {
-        type: string;
-        name: string;
-        id: string;
-        profileId: 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;
-        resetPassword: boolean;
-        createdAt: string;
-        updatedAt: string;
-        access: string[];
-    }>;
-};
-export type LogInDTO = z.infer<typeof LogInDTOSchema>;
-export {};