@temboplus/afloat 0.1.77-beta.9 → 0.1.79

package/script/npm/src/src/features/payout/contract.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contract = exports.DEFAULT_ORDER_BY_DESC = exports.DEFAULT_PAYOUT_API_EAGER = void 0;
+const index_js_1 = require("../../models/payout/index.js");
+const api_error_js_1 = require("../../errors/api_error.js");
+const core_1 = require("@ts-rest/core");
+const zod_1 = require("zod");
+/** Default eager loading settings for payout API */
+exports.DEFAULT_PAYOUT_API_EAGER = "[createdBy,actionedBy]";
+/** Default sort order for payout listings */
+exports.DEFAULT_ORDER_BY_DESC = "createdAt";
+/**
+ * Payout management API contract
+ * Defines endpoints for creating and managing payouts
+ *
+ * @property {Object} getPayouts - List payouts with filtering (GET /)
+ * @property {Object} getPayoutsByApprovalStatus - List payouts by approval status (GET /)
+ * @property {Object} postPayout - Create new payout (POST /)
+ * @property {Object} approve - Approve/reject payout (POST /:id/approve)
+ */
+exports.contract = (0, core_1.initContract)().router({
+    getPayouts: {
+        method: "GET",
+        path: "",
+        query: zod_1.z.object({
+            rangeStart: zod_1.z.number(),
+            rangeEnd: zod_1.z.number(),
+            eager: zod_1.z.string(),
+            approvalStatus: index_js_1.PayoutSchemas.payoutApprovalStatus.nullable().optional(),
+            orderByDesc: zod_1.z.string(),
+        }),
+        responses: {
+            200: zod_1.z.object({
+                results: zod_1.z.array(index_js_1.PayoutSchemas.payoutData),
+                total: zod_1.z.number(),
+            }),
+        },
+    },
+    getPayoutsByApprovalStatus: {
+        method: "GET",
+        path: "",
+        query: zod_1.z.object({
+            rangeStart: zod_1.z.number(),
+            rangeEnd: zod_1.z.number(),
+            eager: zod_1.z.string(),
+            approvalStatus: index_js_1.PayoutSchemas.payoutApprovalStatus,
+            orderByDesc: zod_1.z.string(),
+        }),
+        responses: {
+            200: zod_1.z.object({
+                results: zod_1.z.array(index_js_1.PayoutSchemas.payoutData),
+                total: zod_1.z.number(),
+            }),
+        },
+    },
+    postPayout: {
+        method: "POST",
+        path: "",
+        body: index_js_1.PayoutSchemas.payoutInput,
+        responses: {
+            201: index_js_1.PayoutSchemas.payoutData,
+            400: api_error_js_1.APIError.schema,
+        },
+    },
+    approve: {
+        method: "POST",
+        path: "/:id/approve",
+        body: zod_1.z.object({
+            action: zod_1.z.enum(["Approve", "Reject"]),
+            notes: zod_1.z.string().optional(),
+        }),
+        responses: {
+            201: index_js_1.PayoutSchemas.payoutData,
+            404: zod_1.z.object({}),
+            409: zod_1.z.object({}),
+        },
+    },
+});

package/script/npm/src/src/features/payout/index.d.ts

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

package/script/npm/src/src/features/payout/index.d.ts.map

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

package/script/npm/src/src/features/payout/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./repository.js"), exports);

package/script/npm/src/src/features/payout/repository.d.ts

@@ -0,0 +1,67 @@
+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/script/npm/src/src/features/payout/repository.d.ts.map

@@ -0,0 +1 @@
+{"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;IAoB9C;;;;;;;;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/script/npm/src/src/features/payout/repository.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PayoutRepository = void 0;
+const index_js_1 = require("../../shared/index.js");
+const contract_js_1 = require("./contract.js");
+const index_js_2 = require("../../models/payout/index.js");
+const permission_js_1 = require("../../models/permission.js");
+const index_js_3 = require("../../errors/index.js");
+const payout_js_1 = require("../../models/payout/derivatives/payout.js");
+/**
+ * Repository class for managing payout operations including creation, approval,
+ * rejection, and retrieval of payouts.
+ * @extends {BaseRepository<PayoutAPI>}
+ */
+class PayoutRepository extends index_js_1.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_js_1.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 = permission_js_1.Permissions.Payout.List;
+        if (!auth.checkPermission(requiredPerm)) {
+            throw new index_js_3.PermissionError({
+                message: "You are not authorized to view payouts.",
+                requiredPermissions: [requiredPerm],
+            });
+        }
+        const rangeStart = args?.rangeStart ?? 0;
+        const rangeEnd = args?.rangeEnd ?? 10;
+        const pendingStatus = index_js_2.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 index_js_3.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_js_1.Payout.createMany(result.body.results),
+                total: result.body.total,
+            };
+        }
+        throw index_js_3.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 = permission_js_1.Permissions.Payout.Create;
+        if (!auth.checkPermission(requiredPerm)) {
+            throw new index_js_3.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_js_1.Payout.create(result.body);
+        if (result.status === 400) {
+            throw new index_js_3.APIError(result.body);
+        }
+        throw index_js_3.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 = permission_js_1.Permissions.Payout.Approve;
+        if (!auth.checkPermission(requiredPerm)) {
+            throw new index_js_3.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_js_1.Payout.create(result.body);
+        }
+        if (result.status === 404) {
+            throw new index_js_3.APIError({ message: "Payout not found", statusCode: 404 });
+        }
+        if (result.status === 409) {
+            throw new index_js_3.APIError({
+                message: "Payout already approved",
+                statusCode: 409,
+            });
+        }
+        throw index_js_3.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 = permission_js_1.Permissions.Payout.Approve;
+        if (!auth.checkPermission(requiredPerm)) {
+            throw new index_js_3.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_js_1.Payout.create(result.body);
+        }
+        if (result.status === 404) {
+            throw new index_js_3.APIError({ message: "Payout not found", statusCode: 404 });
+        }
+        if (result.status === 409) {
+            throw new index_js_3.APIError({
+                message: "Payout already rejected",
+                statusCode: 409,
+            });
+        }
+        throw index_js_3.APIError.unknown();
+    }
+}
+exports.PayoutRepository = PayoutRepository;

package/script/npm/src/src/features/wallet/contract.d.ts

@@ -0,0 +1,137 @@
+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/script/npm/src/src/features/wallet/contract.d.ts.map

@@ -0,0 +1 @@
+{"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/script/npm/src/src/features/wallet/contract.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contract = void 0;
+const zod_1 = require("zod");
+const core_1 = require("@ts-rest/core");
+const index_js_1 = require("../../models/wallet/index.js");
+exports.contract = (0, core_1.initContract)().router({
+    getWallets: {
+        method: "GET",
+        path: "/",
+        query: index_js_1.WalletSchemas.walletQuery,
+        responses: {
+            200: zod_1.z.array(index_js_1.WalletSchemas.wallet),
+        },
+    },
+    getBalance: {
+        method: "POST",
+        path: "/balance",
+        body: zod_1.z.object({
+            accountNo: zod_1.z.string().optional(),
+        }),
+        responses: {
+            201: zod_1.z.object({
+                availableBalance: zod_1.z.coerce.number(),
+            }),
+        },
+    },
+    getStatement: {
+        method: "POST",
+        path: "/statement",
+        summary: "Get Wallet Statement",
+        body: zod_1.z.object({
+            endDate: zod_1.z.date(),
+            startDate: zod_1.z.date(),
+            accountNo: zod_1.z.string().optional(),
+        }),
+        responses: {
+            201: zod_1.z.array(index_js_1.WalletSchemas.statementEntry),
+        },
+    },
+});

package/script/npm/src/src/features/wallet/index.d.ts

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

package/script/npm/src/src/features/wallet/index.d.ts.map

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

package/script/npm/src/src/features/wallet/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./repository.js"), exports);

package/script/npm/src/src/features/wallet/repository.d.ts

@@ -0,0 +1,57 @@
+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/script/npm/src/src/features/wallet/repository.d.ts.map

@@ -0,0 +1 @@
+{"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"}