@temboplus/afloat 0.1.61 → 0.1.63

package/esm/src/features/payout/repository.js

@@ -1,163 +0,0 @@
-import { BaseRepository } from "../../shared/index.js";
-import { contract } from "./contract.js";
-import { PAYOUT_APPROVAL_STATUS, } from "../../models/payout/index.js";
-import { Permissions } from "../../models/permission.js";
-import { APIError, PermissionError } from "../../errors/index.js";
-import { Payout } from "../../models/payout/derivatives/payout.js";
-/**
- * Repository class for managing payout operations including creation, approval,
- * rejection, and retrieval of payouts.
- * @extends {BaseRepository<PayoutAPI>}
- */
-export class PayoutRepository extends BaseRepository {
-    /**
-     * Creates an instance of PayoutRepository initialized with the payout contract.
-     * @param {Object} [props] - Optional constructor properties
-     * @param {AfloatAuth} [props.auth] - Optional auth instance to use
-     */
-    constructor(props) {
-        super("payout", contract, { auth: props?.auth });
-    }
-    /**
-     * Retrieves a paginated list of payouts with optional filtering for pending status.
-     * @param {GetPayoutsAPIArgs} [args] - Optional arguments for filtering and pagination
-     * @param {number} [args.rangeStart=0] - Starting index for pagination
-     * @param {number} [args.rangeEnd=10] - Ending index for pagination
-     * @param {boolean} [args.pending] - Filter for pending payouts only
-     * @throws {PermissionError} If user lacks the Payout.List permission
-     * @throws {APIError} If range is invalid or if the fetch operation fails
-     * @returns {Promise<{results: Payout[]; total: number}>} Paginated payout results and total count
-     */
-    async getAll(args) {
-        const auth = this.getAuthForPermissionCheck();
-        const requiredPerm = Permissions.Payout.List;
-        if (!auth.checkPermission(requiredPerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to view payouts.",
-                requiredPermissions: [requiredPerm],
-            });
-        }
-        const rangeStart = args?.rangeStart ?? 0;
-        const rangeEnd = args?.rangeEnd ?? 10;
-        const pendingStatus = PAYOUT_APPROVAL_STATUS.PENDING;
-        const query = {
-            rangeStart,
-            rangeEnd,
-            eager: "[createdBy,actionedBy]",
-            orderByDesc: "createdAt",
-        };
-        if (args?.pending) {
-            Object.assign(query, { approvalStatus: pendingStatus });
-        }
-        if (rangeEnd <= rangeStart) {
-            throw new APIError({
-                message: "Invalid range: end-date must be greater than start-date",
-                statusCode: 400,
-            });
-        }
-        const result = await this.client.getPayouts({ query: query });
-        if (result.status === 200) {
-            return {
-                results: Payout.createMany(result.body.results),
-                total: result.body.total,
-            };
-        }
-        throw APIError.unknown("An error occured while fetching payouts");
-    }
-    /**
-     * Creates a new payout with the provided input data.
-     * @param {PayoutInput} input - The payout creation data
-     * @throws {PermissionError} If user lacks the Payout.Create permission
-     * @throws {APIError} If the input is invalid or if the creation operation fails
-     * @returns {Promise<Payout>} The created payout
-     */
-    async pay(input) {
-        const auth = this.getAuthForPermissionCheck();
-        const requiredPerm = Permissions.Payout.Create;
-        if (!auth.checkPermission(requiredPerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to create payouts.",
-                requiredPermissions: [requiredPerm],
-            });
-        }
-        const result = await this.client.postPayout({ body: input });
-        if (result.status === 201)
-            return Payout.create(result.body);
-        if (result.status === 400) {
-            throw new APIError(result.body);
-        }
-        throw APIError.unknown();
-    }
-    /**
-     * Approves a payout with optional notes.
-     * @param {string} id - The ID of the payout to approve
-     * @param {Object} [args] - Optional arguments
-     * @param {string} [args.notes] - Optional notes for the approval
-     * @throws {PermissionError} If user lacks the Payout.Approve permission
-     * @throws {APIError} If payout is not found, already approved, or if the operation fails
-     * @returns {Promise<Payout>} The approved payout
-     */
-    async approve(id, args) {
-        const auth = this.getAuthForPermissionCheck();
-        const requiredPerm = Permissions.Payout.Approve;
-        if (!auth.checkPermission(requiredPerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to approve or reject payouts.",
-                requiredPermissions: [requiredPerm],
-            });
-        }
-        const result = await this.client.approve({
-            params: { id },
-            body: { action: "Approve", notes: args?.notes },
-        });
-        if (result.status === 201) {
-            return Payout.create(result.body);
-        }
-        if (result.status === 404) {
-            throw new APIError({ message: "Payout not found", statusCode: 404 });
-        }
-        if (result.status === 409) {
-            throw new APIError({
-                message: "Payout already approved",
-                statusCode: 409,
-            });
-        }
-        throw APIError.unknown();
-    }
-    /**
-     * Rejects a payout with optional notes.
-     * @param {string} id - The ID of the payout to reject
-     * @param {Object} [args] - Optional arguments
-     * @param {string} [args.notes] - Optional notes for the rejection
-     * @throws {PermissionError} If user lacks the Payout.Approve permission
-     * @throws {APIError} If payout is not found, already rejected, or if the operation fails
-     * @returns {Promise<Payout>} The rejected payout
-     */
-    async reject(id, args) {
-        const auth = this.getAuthForPermissionCheck();
-        const requiredPerm = Permissions.Payout.Approve;
-        if (!auth.checkPermission(requiredPerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to approve or reject payouts.",
-                requiredPermissions: [requiredPerm],
-            });
-        }
-        const result = await this.client.approve({
-            params: { id },
-            body: { action: "Reject", notes: args?.notes },
-        });
-        if (result.status === 201) {
-            return Payout.create(result.body);
-        }
-        if (result.status === 404) {
-            throw new APIError({ message: "Payout not found", statusCode: 404 });
-        }
-        if (result.status === 409) {
-            throw new APIError({
-                message: "Payout already rejected",
-                statusCode: 409,
-            });
-        }
-        throw APIError.unknown();
-    }
-}

package/esm/src/features/wallet/contract.d.ts

@@ -1,137 +0,0 @@
-import { z } from "zod";
-export declare const contract: {
-    getWallets: {
-        query: z.ZodObject<{
-            id: z.ZodOptional<z.ZodString>;
-            profileId: z.ZodOptional<z.ZodString>;
-            accountNo: z.ZodOptional<z.ZodString>;
-            accountName: z.ZodOptional<z.ZodString>;
-            channel: z.ZodOptional<z.ZodString>;
-            countryCode: z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>>;
-            currencyCode: z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>>;
-        }, "strip", z.ZodTypeAny, {
-            id?: string | undefined;
-            accountNo?: string | undefined;
-            channel?: string | undefined;
-            profileId?: string | undefined;
-            accountName?: string | undefined;
-            countryCode?: string | undefined;
-            currencyCode?: string | undefined;
-        }, {
-            id?: string | undefined;
-            accountNo?: string | undefined;
-            channel?: string | undefined;
-            profileId?: string | undefined;
-            accountName?: string | undefined;
-            countryCode?: string | undefined;
-            currencyCode?: string | undefined;
-        }>;
-        method: "GET";
-        path: "/";
-        responses: {
-            200: z.ZodArray<z.ZodObject<{
-                id: z.ZodString;
-                profileId: z.ZodString;
-                accountNo: z.ZodString;
-                accountName: z.ZodString;
-                channel: z.ZodString;
-                countryCode: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
-                currencyCode: z.ZodEffects<z.ZodDefault<z.ZodString>, string, string | undefined>;
-                createdAt: z.ZodString;
-                updatedAt: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                id: string;
-                accountNo: string;
-                channel: string;
-                profileId: string;
-                createdAt: string;
-                updatedAt: string;
-                accountName: string;
-                countryCode: string;
-                currencyCode: string;
-            }, {
-                id: string;
-                accountNo: string;
-                channel: string;
-                profileId: string;
-                createdAt: string;
-                updatedAt: string;
-                accountName: string;
-                countryCode?: string | undefined;
-                currencyCode?: string | undefined;
-            }>, "many">;
-        };
-    };
-    getBalance: {
-        method: "POST";
-        body: z.ZodObject<{
-            accountNo: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            accountNo?: string | undefined;
-        }, {
-            accountNo?: string | undefined;
-        }>;
-        path: "/balance";
-        responses: {
-            201: z.ZodObject<{
-                availableBalance: z.ZodNumber;
-            }, "strip", z.ZodTypeAny, {
-                availableBalance: number;
-            }, {
-                availableBalance: number;
-            }>;
-        };
-    };
-    getStatement: {
-        summary: "Get Wallet Statement";
-        method: "POST";
-        body: z.ZodObject<{
-            endDate: z.ZodDate;
-            startDate: z.ZodDate;
-            accountNo: z.ZodOptional<z.ZodString>;
-        }, "strip", z.ZodTypeAny, {
-            endDate: Date;
-            startDate: Date;
-            accountNo?: string | undefined;
-        }, {
-            endDate: Date;
-            startDate: Date;
-            accountNo?: string | undefined;
-        }>;
-        path: "/statement";
-        responses: {
-            201: z.ZodArray<z.ZodObject<{
-                accountNo: z.ZodEffects<z.ZodOptional<z.ZodString>, string | undefined, string | undefined>;
-                debitOrCredit: z.ZodString;
-                tranRefNo: z.ZodString;
-                narration: z.ZodString;
-                txnDate: z.ZodDate;
-                valueDate: z.ZodDate;
-                amountCredited: z.ZodNumber;
-                amountDebited: z.ZodNumber;
-                balance: z.ZodNumber;
-            }, "strip", z.ZodTypeAny, {
-                debitOrCredit: string;
-                tranRefNo: string;
-                narration: string;
-                txnDate: Date;
-                valueDate: Date;
-                amountCredited: number;
-                amountDebited: number;
-                balance: number;
-                accountNo?: string | undefined;
-            }, {
-                debitOrCredit: string;
-                tranRefNo: string;
-                narration: string;
-                txnDate: Date;
-                valueDate: Date;
-                amountCredited: number;
-                amountDebited: number;
-                balance: number;
-                accountNo?: string | undefined;
-            }>, "many">;
-        };
-    };
-};
-//# sourceMappingURL=contract.d.ts.map

package/esm/src/features/wallet/contract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../../../src/src/features/wallet/contract.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCnB,CAAC"}

package/esm/src/features/wallet/contract.js

@@ -1,38 +0,0 @@
-import { z } from "zod";
-import { initContract } from "@ts-rest/core";
-import { WalletSchemas } from "../../models/wallet/index.js";
-export const contract = initContract().router({
-    getWallets: {
-        method: "GET",
-        path: "/",
-        query: WalletSchemas.walletQuery,
-        responses: {
-            200: z.array(WalletSchemas.wallet),
-        },
-    },
-    getBalance: {
-        method: "POST",
-        path: "/balance",
-        body: z.object({
-            accountNo: z.string().optional(),
-        }),
-        responses: {
-            201: z.object({
-                availableBalance: z.coerce.number(),
-            }),
-        },
-    },
-    getStatement: {
-        method: "POST",
-        path: "/statement",
-        summary: "Get Wallet Statement",
-        body: z.object({
-            endDate: z.date(),
-            startDate: z.date(),
-            accountNo: z.string().optional(),
-        }),
-        responses: {
-            201: z.array(WalletSchemas.statementEntry),
-        },
-    },
-});

package/esm/src/features/wallet/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./repository.js";
-//# sourceMappingURL=index.d.ts.map

package/esm/src/features/wallet/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/src/features/wallet/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC"}

package/esm/src/features/wallet/index.js

@@ -1 +0,0 @@
-export * from "./repository.js";

package/esm/src/features/wallet/repository.d.ts

@@ -1,57 +0,0 @@
-import { BaseRepository } from "../../shared/base_repository.js";
-import { contract } from "./contract.js";
-import { Wallet, type WalletSchemas, WalletStatementEntry } from "../../models/wallet/index.js";
-import type { AfloatAuth } from "../auth/manager.js";
-import type z from "zod";
-/**
- * Repository class for managing wallet operations including balance checking,
- * statement generation, and wallet information retrieval.
- * @extends {BaseRepository<typeof contract>}
- */
-export declare class WalletRepo extends BaseRepository<typeof contract> {
-    /**
-     * Creates an instance of WalletRepo initialized with the wallet contract.
-     * @param {Object} [options] - Optional configuration
-     * @param {string} [options.root] - Custom API root URL
-     * @param {AfloatAuth} [options.auth] - Auth instance to use
-     */
-    constructor(props?: {
-        root?: string;
-        auth?: AfloatAuth;
-    });
-    /**
-     * Retrieves the current available balance for the wallet.
-     * @throws {PermissionError} If user lacks the ViewBalance permission
-     * @throws {Error} If the balance fetch operation fails
-     * @returns {Promise<number>} The available balance amount
-     */
-    getBalance(props: {
-        accountNo?: string;
-    }): Promise<number>;
-    /**
-     * Retrieves all wallets associated with the current context.
-     * @throws {Error} If the wallet fetch operation fails
-     * @returns {Promise<Wallet[]>} Array of wallet objects
-     */
-    getWallets(args?: z.infer<typeof WalletSchemas.walletQuery>): Promise<Wallet[]>;
-    /**
-     * Retrieves wallet statement items for a specified date range and account.
-     * If no range is provided, defaults to the current month (1st to 30th).
-     * @param {Object} props - The statement request properties
-     * @param {Object} [props.range] - Optional date range for the statement
-     * @param {Date} props.range.startDate - Start date for the statement period
-     * @param {Date} props.range.endDate - End date for the statement period
-     * @param {string} [props.accountNo] - Optional account number to fetch statement for
-     * @throws {PermissionError} If user lacks the ViewStatement permission
-     * @throws {Error} If the statement fetch operation fails
-     * @returns {Promise<WalletStatementEntry[]>} Array of statement items for the specified period
-     */
-    getStatement(props: {
-        range?: {
-            startDate: Date;
-            endDate: Date;
-        };
-        accountNo?: string;
-    }): Promise<WalletStatementEntry[]>;
-}
-//# sourceMappingURL=repository.d.ts.map

package/esm/src/features/wallet/repository.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../src/src/features/wallet/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EACL,MAAM,EACN,KAAK,aAAa,EAClB,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC;AAEzB;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,cAAc,CAAC,OAAO,QAAQ,CAAC;IAC7D;;;;;OAKG;gBACS,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,UAAU,CAAA;KAAE;IAOxD;;;;;OAKG;IACG,UAAU,CAAC,KAAK,EAAE;QAAE,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAsBhE;;;;OAIG;IACG,UAAU,CACd,IAAI,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,WAAW,CAAC,GAC/C,OAAO,CAAC,MAAM,EAAE,CAAC;IAUpB;;;;;;;;;;;OAWG;IACG,YAAY,CAChB,KAAK,EAAE;QACL,KAAK,CAAC,EAAE;YAAE,SAAS,EAAE,IAAI,CAAC;YAAC,OAAO,EAAE,IAAI,CAAA;SAAE,CAAC;QAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GACA,OAAO,CAAC,oBAAoB,EAAE,CAAC;CA2BnC"}

package/esm/src/features/wallet/repository.js

@@ -1,93 +0,0 @@
-import { BaseRepository } from "../../shared/base_repository.js";
-import { contract } from "./contract.js";
-import { Wallet, WalletStatementEntry, } from "../../models/wallet/index.js";
-import { Permissions } from "../../models/permission.js";
-import { PermissionError } from "../../errors/index.js";
-/**
- * Repository class for managing wallet operations including balance checking,
- * statement generation, and wallet information retrieval.
- * @extends {BaseRepository<typeof contract>}
- */
-export class WalletRepo extends BaseRepository {
-    /**
-     * Creates an instance of WalletRepo initialized with the wallet contract.
-     * @param {Object} [options] - Optional configuration
-     * @param {string} [options.root] - Custom API root URL
-     * @param {AfloatAuth} [options.auth] - Auth instance to use
-     */
-    constructor(props) {
-        super("wallet", contract, {
-            root: props?.root,
-            auth: props?.auth,
-        });
-    }
-    /**
-     * Retrieves the current available balance for the wallet.
-     * @throws {PermissionError} If user lacks the ViewBalance permission
-     * @throws {Error} If the balance fetch operation fails
-     * @returns {Promise<number>} The available balance amount
-     */
-    async getBalance(props) {
-        const auth = this.getAuthForPermissionCheck();
-        const requirePerm = Permissions.Wallet.ViewBalance;
-        if (!auth.checkPermission(requirePerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to view the account balance.",
-                requiredPermissions: [requirePerm],
-            });
-        }
-        const result = await this.client.getBalance({
-            body: { accountNo: props.accountNo },
-        });
-        if (result.status === 201) {
-            return result.body.availableBalance;
-        }
-        throw new Error("An error occured while fetching balance");
-    }
-    /**
-     * Retrieves all wallets associated with the current context.
-     * @throws {Error} If the wallet fetch operation fails
-     * @returns {Promise<Wallet[]>} Array of wallet objects
-     */
-    async getWallets(args) {
-        const result = await this.client.getWallets({ query: args });
-        if (result.status === 200) {
-            return result.body.map((w) => Wallet.from(w));
-        }
-        throw new Error("An error occured while fetching wallets");
-    }
-    /**
-     * Retrieves wallet statement items for a specified date range and account.
-     * If no range is provided, defaults to the current month (1st to 30th).
-     * @param {Object} props - The statement request properties
-     * @param {Object} [props.range] - Optional date range for the statement
-     * @param {Date} props.range.startDate - Start date for the statement period
-     * @param {Date} props.range.endDate - End date for the statement period
-     * @param {string} [props.accountNo] - Optional account number to fetch statement for
-     * @throws {PermissionError} If user lacks the ViewStatement permission
-     * @throws {Error} If the statement fetch operation fails
-     * @returns {Promise<WalletStatementEntry[]>} Array of statement items for the specified period
-     */
-    async getStatement(props) {
-        const auth = this.getAuthForPermissionCheck();
-        const requirePerm = Permissions.Wallet.ViewStatement;
-        if (!auth.checkPermission(requirePerm)) {
-            throw new PermissionError({
-                message: "You are not authorized to view the statement.",
-                requiredPermissions: [requirePerm],
-            });
-        }
-        const now = new Date();
-        const monthStart = new Date(now.getFullYear(), now.getMonth(), 1);
-        const monthEnd = new Date(now.getFullYear(), now.getMonth(), 30);
-        const range = props.range !== undefined
-            ? { startDate: props.range.startDate, endDate: props.range.endDate }
-            : { startDate: monthStart, endDate: monthEnd };
-        const body = { ...range, accountNo: props.accountNo };
-        const result = await this.client.getStatement({ body });
-        if (result.status === 201) {
-            return result.body.map((e) => WalletStatementEntry.from(e));
-        }
-        throw new Error("An error occured while fetching statement");
-    }
-}

package/esm/src/models/contact/derivatives/contact.d.ts

@@ -1,172 +0,0 @@
-import { type ContactData, type ContactType } from "../schemas.js";
-import { type ContactInfo } from "./contact_info.js";
-/**
- * Contact class that wraps the Zod schema and provides additional functionality
- */
-export declare class Contact {
-    private readonly data;
-    /**
-     * Private constructor - use static methods to create instances
-     */
-    private constructor();
-    /**
-     * Unique identifier for the contact
-     */
-    get id(): string;
-    /**
-     * Profile identifier associated with this contact
-     */
-    get profileId(): string;
-    /**
-     * Display name of the contact
-     */
-    get displayName(): string;
-    /**
-     * Type of contact (Bank or Mobile)
-     */
-    get type(): ContactType;
-    /**
-     * Creation timestamp of the contact
-     */
-    get createdAt(): Date;
-    /**
-     * Update timestamp of the contact
-     */
-    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;
-    /**
-     * Payment channel for the contact
-     *
-     * @returns {string} Channel information:
-     * - For valid contacts, returns formatted channel from ContactInfo
-     * - For invalid contacts, falls back to account number
-     */
-    get channel(): string;
-    /**
-     * 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
-     */
-    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;
-    /**
-     * Creates a Contact instance from raw data
-     * @throws {ZodError} if validation fails
-     */
-    static create(data: ContactData): Contact;
-    /**
-     * Creates multiple Contact instances from an array of raw data
-     * @throws {ZodError} if validation fails for any item
-     */
-    static createMany(dataArray: ContactData[]): Contact[];
-    /**
-     * Creates a Contact instance from raw data without throwing
-     * @returns {Contact | null} Contact instance or null if validation fails
-     */
-    static createSafe(data: ContactData): 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.
-     *
-     * @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);
-     *   // TypeScript knows contact is valid here
-     *   console.log(contact.displayName);
-     * }
-     * ```
-     *
-     * @throws {never} This method never throws errors
-     *
-     * @remarks
-     * This method performs strict validation against the {@link ContactData} 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.
-     *
-     * @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)) {
-     *   // TypeScript knows maybeContact is a Contact here
-     *   console.log(maybeContact.displayName);
-     * }
-     * ```
-     *
-     * @throws {never} This method never throws errors
-     *
-     * @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 ContactData 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;
-    /**
-     * Converts Payout instance to a plain object
-     */
-    toJSON(): ContactData;
-}
-//# sourceMappingURL=contact.d.ts.map