@temboplus/afloat 0.1.0

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

@@ -0,0 +1,75 @@
+import { PayoutSchemas } from "../../models/payout/index.js";
+import { APIError } from "../../errors/api_error.js";
+import { initContract } from "@ts-rest/core";
+import { z } from "zod";
+/** Default eager loading settings for payout API */
+export const DEFAULT_PAYOUT_API_EAGER = "[createdBy,actionedBy]";
+/** Default sort order for payout listings */
+export const 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)
+ */
+export const contract = initContract().router({
+    getPayouts: {
+        method: "GET",
+        path: "",
+        query: z.object({
+            rangeStart: z.number(),
+            rangeEnd: z.number(),
+            eager: z.string(),
+            approvalStatus: PayoutSchemas.payoutApprovalStatus.nullable().optional(),
+            orderByDesc: z.string(),
+        }),
+        responses: {
+            200: z.object({
+                results: z.array(PayoutSchemas.payoutData),
+                total: z.number(),
+            }),
+        },
+    },
+    getPayoutsByApprovalStatus: {
+        method: "GET",
+        path: "",
+        query: z.object({
+            rangeStart: z.number(),
+            rangeEnd: z.number(),
+            eager: z.string(),
+            approvalStatus: PayoutSchemas.payoutApprovalStatus,
+            orderByDesc: z.string(),
+        }),
+        responses: {
+            200: z.object({
+                results: z.array(PayoutSchemas.payoutData),
+                total: z.number(),
+            }),
+        },
+    },
+    postPayout: {
+        method: "POST",
+        path: "",
+        body: PayoutSchemas.payoutInput,
+        responses: {
+            201: PayoutSchemas.payoutData,
+            400: APIError.schema,
+        },
+    },
+    approve: {
+        method: "POST",
+        path: "/:id/approve",
+        body: z.object({
+            action: z.enum(["Approve", "Reject"]),
+            notes: z.string().optional(),
+        }),
+        responses: {
+            201: PayoutSchemas.payoutData,
+            404: z.object({}),
+            409: z.object({}),
+        },
+    },
+});

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

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

package/esm/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/esm/src/features/payout/index.js

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

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

@@ -0,0 +1,62 @@
+import { BaseRepository } from "../../shared/index.js";
+import { type PayoutAPI } from "./contract.js";
+import { type GetPayoutsAPIArgs, type PayoutInput } from "../../models/payout/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 declare class PayoutRepository extends BaseRepository<PayoutAPI> {
+    /**
+     * Creates an instance of PayoutRepository initialized with the payout contract.
+     */
+    constructor();
+    /**
+     * 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

@@ -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;AAItC,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAEnE;;;;GAIG;AACH,qBAAa,gBAAiB,SAAQ,cAAc,CAAC,SAAS,CAAC;IAC7D;;OAEG;;IAKH;;;;;;;;;OASG;IACG,MAAM,CAAC,IAAI,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC;QAC9C,OAAO,EAAE,MAAM,EAAE,CAAC;QAClB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IA2CF;;;;;;OAMG;IACG,GAAG,CAAC,KAAK,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;IAkB9C;;;;;;;;OAQG;IACG,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;IA8BrE;;;;;;;;OAQG;IACG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC;CA6BrE"}

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

@@ -0,0 +1,158 @@
+import { BaseRepository } from "../../shared/index.js";
+import { contract } from "./contract.js";
+import { PAYOUT_APPROVAL_STATUS, } from "../../models/payout/index.js";
+import { AfloatAuth } from "../auth/manager.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.
+     */
+    constructor() {
+        super("payout", contract);
+    }
+    /**
+     * 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 requiredPerm = Permissions.Payout.List;
+        if (!AfloatAuth.instance.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 requiredPerm = Permissions.Payout.Create;
+        if (!AfloatAuth.instance.checkPermission(Permissions.Payout.Create)) {
+            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 requiredPerm = Permissions.Payout.Approve;
+        if (!AfloatAuth.instance.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 requiredPerm = Permissions.Payout.Approve;
+        if (!AfloatAuth.instance.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

@@ -0,0 +1,103 @@
+import { z } from "zod";
+export declare const contract: {
+    getWallets: {
+        method: "GET";
+        path: "/";
+        responses: {
+            200: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                profileId: z.ZodString;
+                accountNo: z.ZodString;
+                accountName: z.ZodString;
+                channel: z.ZodString;
+                createdAt: z.ZodString;
+                updatedAt: z.ZodString;
+            }, z.UnknownKeysParam, z.ZodTypeAny, {
+                id: string;
+                accountNo: string;
+                channel: string;
+                profileId: string;
+                createdAt: string;
+                updatedAt: string;
+                accountName: string;
+            }, {
+                id: string;
+                accountNo: string;
+                channel: string;
+                profileId: string;
+                createdAt: string;
+                updatedAt: string;
+                accountName: string;
+            }>, "many">;
+        };
+    };
+    getBalance: {
+        method: "POST";
+        body: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        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>>;
+                cbaRefNo: z.ZodEffects<z.ZodOptional<z.ZodString>>;
+                debitOrCredit: z.ZodString;
+                tranRefNo: z.ZodString;
+                narration: z.ZodString;
+                txnDate: z.ZodDate;
+                valueDate: z.ZodDate;
+                amountCredited: z.ZodNumber;
+                amountDebited: z.ZodNumber;
+                balance: z.ZodNumber;
+            }, z.UnknownKeysParam, z.ZodTypeAny, {
+                debitOrCredit: string;
+                tranRefNo: string;
+                narration: string;
+                txnDate: Date;
+                valueDate: Date;
+                amountCredited: number;
+                amountDebited: number;
+                balance: number;
+                accountNo?: string | undefined;
+                cbaRefNo?: string | undefined;
+            }, {
+                debitOrCredit: string;
+                tranRefNo: string;
+                narration: string;
+                txnDate: Date;
+                valueDate: Date;
+                amountCredited: number;
+                amountDebited: number;
+                balance: number;
+                accountNo?: string | undefined;
+                cbaRefNo?: string | undefined;
+            }>, "many">;
+        };
+    };
+};
+//# sourceMappingURL=contract.d.ts.map

package/esm/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BnB,CAAC"}

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

@@ -0,0 +1,35 @@
+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: "/",
+        responses: {
+            200: z.array(WalletSchemas.wallet),
+        },
+    },
+    getBalance: {
+        method: "POST",
+        path: "/balance",
+        body: z.object({}),
+        responses: {
+            201: z.object({
+                availableBalance: z.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

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

package/esm/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/esm/src/features/wallet/index.js

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

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

@@ -0,0 +1,74 @@
+import { BaseRepository } from "../../shared/base_repository.js";
+import { contract } from "./contract.js";
+import type { STATEMENT_OUTPUT_TYPE, StatementFile, Wallet, WalletStatementItem } from "../../models/wallet/index.js";
+/**
+ * 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.
+     */
+    constructor();
+    /**
+     * Gets an instance of the file generation repository.
+     * @private
+     * @returns {AfloatFilesRepo} A new instance of AfloatFilesRepo
+     */
+    private get fileGenRepo();
+    /**
+     * 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(): 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(): 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<WalletStatementItem[]>} Array of statement items for the specified period
+     */
+    getStatement(props: {
+        range?: {
+            startDate: Date;
+            endDate: Date;
+        };
+        accountNo?: string;
+    }): Promise<WalletStatementItem[]>;
+    /**
+     * Generates a statement file for the specified period and account.
+     * @param {STATEMENT_OUTPUT_TYPE} fileType - The desired output format type for the statement
+     * @param {Object} props - The statement generation properties
+     * @param {Date} props.startDate - Start date for the statement period
+     * @param {Date} props.endDate - End date for the statement period
+     * @param {string} [props.accountNo] - Optional account number to generate statement for
+     * @throws {PermissionError} If user lacks the ViewStatement permission
+     * @returns {Promise<StatementFile>} The generated statement file
+     */
+    genStatement(fileType: STATEMENT_OUTPUT_TYPE, props: {
+        startDate: Date;
+        endDate: Date;
+        accountNo?: string;
+    }): Promise<StatementFile>;
+    /**
+     * Generates a PDF containing detailed wallet account information.
+     * @throws {PermissionError} If user lacks the ViewBalance permission
+     * @returns {Promise<StatementFile>} The generated PDF file containing wallet details
+     */
+    genWalletDetailsPDF(): Promise<StatementFile>;
+}
+//# sourceMappingURL=repository.d.ts.map

package/esm/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,KAAK,EACV,qBAAqB,EACrB,aAAa,EACb,MAAM,EACN,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAMtC;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,cAAc,CAAC,OAAO,QAAQ,CAAC;IAC7D;;OAEG;;IAKH;;;;OAIG;IACH,OAAO,KAAK,WAAW,GAEtB;IAED;;;;;OAKG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,CAAC;IAkBnC;;;;OAIG;IACG,UAAU,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAUrC;;;;;;;;;;;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,mBAAmB,EAAE,CAAC;IA0BjC;;;;;;;;;OASG;IACG,YAAY,CAChB,QAAQ,EAAE,qBAAqB,EAC/B,KAAK,EAAE;QACL,SAAS,EAAE,IAAI,CAAC;QAChB,OAAO,EAAE,IAAI,CAAC;QACd,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,GACA,OAAO,CAAC,aAAa,CAAC;IAiBzB;;;;OAIG;IACG,mBAAmB,IAAI,OAAO,CAAC,aAAa,CAAC;CAWpD"}

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

@@ -0,0 +1,132 @@
+import { BaseRepository } from "../../shared/base_repository.js";
+import { contract } from "./contract.js";
+import { AfloatFilesRepo } from "../files-gen/repository.js";
+import { AfloatAuth } from "../auth/manager.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.
+     */
+    constructor() {
+        super("wallet", contract);
+    }
+    /**
+     * Gets an instance of the file generation repository.
+     * @private
+     * @returns {AfloatFilesRepo} A new instance of AfloatFilesRepo
+     */
+    get fileGenRepo() {
+        return new AfloatFilesRepo();
+    }
+    /**
+     * 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() {
+        const requirePerm = Permissions.Wallet.ViewBalance;
+        if (!AfloatAuth.instance.checkPermission(requirePerm)) {
+            throw new PermissionError({
+                message: "You are not authorized to view the account balance.",
+                requiredPermissions: [requirePerm],
+            });
+        }
+        const result = await this.client.getBalance();
+        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() {
+        const result = await this.client.getWallets();
+        if (result.status === 200) {
+            return result.body;
+        }
+        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<WalletStatementItem[]>} Array of statement items for the specified period
+     */
+    async getStatement(props) {
+        const requirePerm = Permissions.Wallet.ViewStatement;
+        if (!AfloatAuth.instance.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;
+        }
+        throw new Error("An error occured while fetching statement");
+    }
+    /**
+     * Generates a statement file for the specified period and account.
+     * @param {STATEMENT_OUTPUT_TYPE} fileType - The desired output format type for the statement
+     * @param {Object} props - The statement generation properties
+     * @param {Date} props.startDate - Start date for the statement period
+     * @param {Date} props.endDate - End date for the statement period
+     * @param {string} [props.accountNo] - Optional account number to generate statement for
+     * @throws {PermissionError} If user lacks the ViewStatement permission
+     * @returns {Promise<StatementFile>} The generated statement file
+     */
+    async genStatement(fileType, props) {
+        const requirePerm = Permissions.Wallet.ViewStatement;
+        if (!AfloatAuth.instance.checkPermission(requirePerm)) {
+            throw new PermissionError({
+                message: "You are not authorized to view the statement.",
+                requiredPermissions: [requirePerm],
+            });
+        }
+        return await this.fileGenRepo.downloadStatement({
+            start_date: props.startDate,
+            end_date: props.endDate,
+            return_file_type: fileType,
+            account_no: props.accountNo,
+        });
+    }
+    /**
+     * Generates a PDF containing detailed wallet account information.
+     * @throws {PermissionError} If user lacks the ViewBalance permission
+     * @returns {Promise<StatementFile>} The generated PDF file containing wallet details
+     */
+    async genWalletDetailsPDF() {
+        const requirePerm = Permissions.Wallet.ViewBalance;
+        if (!AfloatAuth.instance.checkPermission(requirePerm)) {
+            throw new PermissionError({
+                message: "You are not authorized to view the account details.",
+                requiredPermissions: [requirePerm],
+            });
+        }
+        return await this.fileGenRepo.genAccountDetailsPDF();
+    }
+}