@temboplus/afloat 0.1.81 → 0.2.0-beta.2

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

@@ -1,67 +0,0 @@
-import { BaseRepository } from "../../shared/index.js";
-import { type PayoutAPI } from "./contract.js";
-import { type GetPayoutsAPIArgs, type PayoutInput } from "../../models/payout/index.js";
-import type { AfloatAuth } from "../auth/manager.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 declare class PayoutRepository extends BaseRepository<PayoutAPI> {
-    /**
-     * 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?: {
-        auth?: AfloatAuth;
-    });
-    /**
-     * 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
-     */
-    getAll(args?: GetPayoutsAPIArgs): Promise<{
-        results: Payout[];
-        total: number;
-    }>;
-    /**
-     * 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
-     */
-    pay(input: PayoutInput): Promise<Payout>;
-    /**
-     * 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
-     */
-    approve(id: string, args?: {
-        notes?: string;
-    }): Promise<Payout>;
-    /**
-     * 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
-     */
-    reject(id: string, args?: {
-        notes?: string;
-    }): Promise<Payout>;
-}
-//# sourceMappingURL=repository.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"repository.d.ts","sourceRoot":"","sources":["../../../../src/src/features/payout/repository.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAY,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AACzD,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,WAAW,EACjB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,cAAc,CAAC,SAAS,CAAC;IAC7D;;;;OAIG;gBACS,KAAK,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,UAAU,CAAA;KAAE;IAIzC;;;;;;;;;OASG;IACG,MAAM,CAAC,IAAI,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC;QAC9C,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IA6CF;;;;;;OAMG;IACG,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAsC9C;;;;;;;;OAQG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IAgCrE;;;;;;;;OAQG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;CA+BrE"}

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

@@ -1,179 +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],
-            });
-        }
-        // Clean MSISDN: trim + remove all internal spaces (space, tab, newline)
-        const sanitizeMsisdn = (value) => {
-            if (!value)
-                return value;
-            return value
-                .trim() // remove leading & trailing whitespace
-                .replace(/\s+/g, ""); // remove ANY whitespace inside (spaces, tabs, newlines)
-        };
-        const body = {
-            description: input.description?.trim(),
-            amount: input.amount,
-            channel: input.channel,
-            msisdn: sanitizeMsisdn(input.msisdn),
-            payeeName: input.payeeName?.trim(),
-            notes: input.notes?.trim(),
-        };
-        const result = await this.client.postPayout({ body });
-        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");
-    }
-}