@classytic/commerce-sdk 0.1.0

package/dist/transaction/index.d.ts

@@ -0,0 +1,104 @@
+import { o as Transaction, C as CreateTransactionPayload, U as UpdateTransactionPayload, F as FinancialReport, q as CashFlowReport, r as CategoryReport, s as StatementResponse } from '../transaction-BTmoHpWh.js';
+export { a as PaymentGatewayType, p as PaymentIntent, P as PaymentMethod, S as StatementRow, i as TaxType, e as TransactionCategory, f as TransactionCategoryType, l as TransactionCommission, T as TransactionFlow, b as TransactionFlowType, k as TransactionGateway, h as TransactionPaymentDetails, n as TransactionReconciliation, g as TransactionSplitPayment, c as TransactionStatus, d as TransactionStatusType, j as TransactionTaxDetails, t as TransactionType, m as TransactionWebhook } from '../transaction-BTmoHpWh.js';
+import { R as ReportParams, C as CashFlowParams, a as CategoryParams, S as StatementParams } from '../transaction-u5oaNuav.js';
+export { T as TransactionApi, t as transactionApi, t as transactionApiDefault } from '../transaction-u5oaNuav.js';
+import * as _tanstack_react_query from '@tanstack/react-query';
+import { b as CrudHooksReturn, L as ListOptions, l as ListQueryResult, D as DetailOptions, m as DetailQueryResult, d as CrudActions, N as NavigateFn } from '../crud.factory-DyKaPHcU.js';
+import '../api-factory-B_h4RKBm.js';
+
+declare const TRANSACTION_KEYS: {
+    all: readonly ["transactions"];
+    lists: () => readonly ["transactions", "list"];
+    list: (params: Record<string, unknown>) => readonly ["transactions", "list", Record<string, unknown>];
+    details: () => readonly ["transactions", "detail"];
+    detail: (id: string) => readonly ["transactions", "detail", string];
+    reports: () => readonly ["transactions", "reports"];
+    profitLoss: (params: ReportParams) => readonly ["transactions", "reports", "profit-loss", ReportParams];
+    cashFlow: (params: CashFlowParams) => readonly ["transactions", "reports", "cash-flow", CashFlowParams];
+    categories: (params: CategoryParams) => readonly ["transactions", "reports", "categories", CategoryParams];
+    statement: (params: StatementParams) => readonly ["transactions", "reports", "statement", StatementParams];
+};
+/**
+ * Transaction CRUD hooks using createCrudHooks factory
+ *
+ * Provides:
+ * - useTransactions: List transactions with filtering/pagination
+ * - useTransactionDetail: Get single transaction
+ * - useTransactionActions: Create, update, delete mutations
+ * - useTransactionNavigation: Navigation between transactions
+ */
+declare const transactionHooks: CrudHooksReturn<Transaction, CreateTransactionPayload, UpdateTransactionPayload>;
+declare const useTransactions: (token: string | null, params?: Record<string, unknown>, options?: ListOptions) => ListQueryResult<Transaction>;
+declare const useTransactionDetail: (id: string | null, token: string | null, options?: DetailOptions) => DetailQueryResult<Transaction>;
+declare const useTransactionActions: () => CrudActions<CreateTransactionPayload, UpdateTransactionPayload>;
+declare const useTransactionNavigation: () => NavigateFn<Transaction>;
+interface QueryOptions {
+    enabled?: boolean;
+    staleTime?: number;
+}
+/**
+ * Fetch Profit & Loss report
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useProfitLoss({
+ *   startDate: '2024-01-01',
+ *   endDate: '2024-12-31',
+ * });
+ *
+ * return (
+ *   <div>
+ *     <p>Income: {data?.income}</p>
+ *     <p>Expense: {data?.expense}</p>
+ *     <p>Net: {data?.net}</p>
+ *   </div>
+ * );
+ * ```
+ */
+declare function useProfitLoss(params: ReportParams, options?: QueryOptions): _tanstack_react_query.UseQueryResult<FinancialReport, Error>;
+/**
+ * Fetch Cash Flow report (monthly trend)
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading } = useCashFlow({ months: 6 });
+ *
+ * return (
+ *   <BarChart data={data?.months} />
+ * );
+ * ```
+ */
+declare function useCashFlow(params?: CashFlowParams, options?: QueryOptions): _tanstack_react_query.UseQueryResult<CashFlowReport, Error>;
+/**
+ * Fetch Category breakdown report
+ *
+ * @example
+ * ```tsx
+ * // Get expense categories
+ * const { data } = useCategoryReport({ flow: 'outflow', limit: 10 });
+ *
+ * return (
+ *   <PieChart data={data?.categories} />
+ * );
+ * ```
+ */
+declare function useCategoryReport(params?: CategoryParams, options?: QueryOptions): _tanstack_react_query.UseQueryResult<CategoryReport, Error>;
+/**
+ * Fetch Statement export (JSON format)
+ *
+ * @example
+ * ```tsx
+ * const { data } = useStatement({
+ *   startDate: '2024-01-01',
+ *   endDate: '2024-12-31',
+ *   format: 'json',
+ * });
+ *
+ * return (
+ *   <DataTable data={data?.data} />
+ * );
+ * ```
+ */
+declare function useStatement(params: StatementParams, options?: QueryOptions): _tanstack_react_query.UseQueryResult<StatementResponse, Error>;
+
+export { CashFlowParams, CashFlowReport, CategoryParams, CategoryReport, CreateTransactionPayload, FinancialReport, ReportParams, StatementParams, StatementResponse, TRANSACTION_KEYS, Transaction, UpdateTransactionPayload, transactionHooks, useCashFlow, useCategoryReport, useProfitLoss, useStatement, useTransactionActions, useTransactionDetail, useTransactionNavigation, useTransactions };

package/dist/transaction/index.js

@@ -0,0 +1,8 @@
+"use client";
+export { TRANSACTION_KEYS, TransactionApi, TransactionCategory, TransactionFlow, TransactionStatus, TransactionType, transactionApi, transaction_default as transactionApiDefault, transactionHooks, useCashFlow, useCategoryReport, useProfitLoss, useStatement, useTransactionActions, useTransactionDetail, useTransactionNavigation, useTransactions } from '../chunk-5ZFW3FEI.js';
+import '../chunk-I5TIKUIQ.js';
+import '../chunk-B6MPVOV7.js';
+import '../chunk-U3XT35GZ.js';
+import '../chunk-VR36QVX2.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/transaction/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/transaction-BTmoHpWh.d.ts

@@ -0,0 +1,428 @@
+/**
+ * Transaction Types
+ *
+ * Transactions track cashflow events across the system.
+ * Used by: Orders, POS, Inventory, CRM, HRM, and manual entries.
+ *
+ * Sources:
+ * - modules/transaction/transaction.model.js
+ * - common/revenue/enums.js
+ * - @classytic/revenue library
+ *
+ * Key concepts:
+ * - `flow`: Direction of money ('inflow' = income, 'outflow' = expense)
+ * - `type`: Category of transaction (order_purchase, refund, rent, etc.)
+ * - Amounts in smallest unit (paisa for BDT)
+ */
+/**
+ * Payment methods supported by the system
+ */
+type PaymentMethod = 'cash' | 'bkash' | 'nagad' | 'rocket' | 'upay' | 'bank_transfer' | 'card' | 'online' | 'manual' | 'split' | 'cod';
+type PaymentGatewayType = 'manual' | 'stripe' | 'sslcommerz' | 'bkash' | 'nagad';
+/**
+ * Transaction Flow - Direction of money movement
+ * - inflow: Money coming in (sales, income, capital injection)
+ * - outflow: Money going out (expenses, refunds, purchases)
+ */
+declare enum TransactionFlow {
+    INFLOW = "inflow",
+    OUTFLOW = "outflow"
+}
+type TransactionFlowType = 'inflow' | 'outflow';
+/**
+ * Transaction Status - Payment lifecycle states
+ */
+declare enum TransactionStatus {
+    PENDING = "pending",
+    PAYMENT_INITIATED = "payment_initiated",
+    PROCESSING = "processing",
+    REQUIRES_ACTION = "requires_action",
+    VERIFIED = "verified",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    CANCELLED = "cancelled",
+    EXPIRED = "expired",
+    REFUNDED = "refunded",
+    PARTIALLY_REFUNDED = "partially_refunded"
+}
+type TransactionStatusType = 'pending' | 'payment_initiated' | 'processing' | 'requires_action' | 'verified' | 'completed' | 'failed' | 'cancelled' | 'expired' | 'refunded' | 'partially_refunded';
+/**
+ * Transaction Categories
+ *
+ * The `type` field stores the category for reporting/grouping.
+ * Flow is determined by `flow` field, not by category.
+ *
+ * ┌─────────────────────────────────────────────────────────────────┐
+ * │ INFLOW (Income)                 │ OUTFLOW (Expense)             │
+ * ├─────────────────────────────────┼───────────────────────────────┤
+ * │ order_purchase (POS/Web sales)  │ inventory_purchase (stock)    │
+ * │ wholesale_sale (B2B sales)      │ purchase_return (refund recv) │
+ * │ capital_injection               │ cogs (cost of goods sold)     │
+ * │ retained_earnings               │ rent, utilities, equipment... │
+ * │ other_income                    │ inventory_loss                │
+ * │ tip_income (optional)           │ marketing, maintenance...     │
+ * │                                 │ refund (customer refunds)     │
+ * └─────────────────────────────────┴───────────────────────────────┘
+ */
+declare enum TransactionCategory {
+    ORDER_PURCHASE = "order_purchase",
+    ORDER_SUBSCRIPTION = "order_subscription",
+    WHOLESALE_SALE = "wholesale_sale",
+    PLATFORM_SUBSCRIPTION = "platform_subscription",
+    CREATOR_SUBSCRIPTION = "creator_subscription",
+    ENROLLMENT_PURCHASE = "enrollment_purchase",
+    ENROLLMENT_SUBSCRIPTION = "enrollment_subscription",
+    INVENTORY_PURCHASE = "inventory_purchase",
+    PURCHASE_RETURN = "purchase_return",
+    INVENTORY_LOSS = "inventory_loss",
+    INVENTORY_ADJUSTMENT = "inventory_adjustment",
+    COGS = "cogs",
+    REFUND = "refund",
+    SUBSCRIPTION = "subscription",
+    PURCHASE = "purchase",
+    RENT = "rent",
+    UTILITIES = "utilities",
+    EQUIPMENT = "equipment",
+    SUPPLIES = "supplies",
+    MAINTENANCE = "maintenance",
+    MARKETING = "marketing",
+    OTHER_EXPENSE = "other_expense",
+    CAPITAL_INJECTION = "capital_injection",
+    RETAINED_EARNINGS = "retained_earnings",
+    TIP_INCOME = "tip_income",
+    OTHER_INCOME = "other_income"
+}
+type TransactionCategoryType = 'order_purchase' | 'order_subscription' | 'wholesale_sale' | 'platform_subscription' | 'creator_subscription' | 'enrollment_purchase' | 'enrollment_subscription' | 'refund' | 'subscription' | 'purchase' | 'inventory_purchase' | 'purchase_return' | 'inventory_loss' | 'inventory_adjustment' | 'cogs' | 'rent' | 'utilities' | 'equipment' | 'supplies' | 'maintenance' | 'marketing' | 'other_expense' | 'capital_injection' | 'retained_earnings' | 'tip_income' | 'other_income';
+/**
+ * Transaction Split Payment - Individual payment in a split transaction
+ * Different from POS SplitPaymentEntry which has additional UI state fields
+ */
+interface TransactionSplitPayment {
+    method: PaymentMethod;
+    amount: number;
+    reference?: string;
+    details?: Record<string, unknown>;
+}
+/**
+ * Payment Details - For manual/split payments
+ */
+interface TransactionPaymentDetails {
+    walletNumber?: string;
+    walletType?: 'personal' | 'merchant';
+    trxId?: string;
+    bankName?: string;
+    accountNumber?: string;
+    accountName?: string;
+    proofUrl?: string;
+    /** Split payment entries (when method is 'split') */
+    payments?: TransactionSplitPayment[];
+}
+/**
+ * Tax type for transactions
+ */
+type TaxType = 'vat' | 'gst' | 'sales_tax' | 'income_tax' | 'withholding_tax' | 'none';
+/**
+ * Tax Details for VAT/GST/Sales Tax tracking
+ */
+interface TransactionTaxDetails {
+    /** Tax type: vat, gst, sales_tax, etc. */
+    type?: TaxType;
+    /** Tax rate as decimal (0.15 = 15%) */
+    rate?: number;
+    /** Whether prices include tax (BD default: true) */
+    isInclusive?: boolean;
+    /** Tax jurisdiction code (e.g., 'BD' for Bangladesh) */
+    jurisdiction?: string;
+}
+/**
+ * Gateway Details - Payment provider info
+ */
+interface TransactionGateway {
+    type: PaymentGatewayType | string;
+    provider?: string;
+    paymentUrl?: string;
+    transactionId?: string;
+    sessionId?: string;
+    paymentIntentId?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Commission tracking for gateway/marketplace payments
+ */
+interface TransactionCommission {
+    /** Commission rate as decimal */
+    rate?: number;
+    /** Gross commission amount */
+    grossAmount?: number;
+    /** Gateway fee rate as decimal */
+    gatewayFeeRate?: number;
+    /** Gateway fee amount */
+    gatewayFeeAmount?: number;
+    /** Net commission amount (grossAmount - gatewayFeeAmount) */
+    netAmount?: number;
+    /** Commission status */
+    status?: 'pending' | 'due' | 'paid' | 'waived' | 'reversed';
+    /** Commission due date (ISO 8601) */
+    dueDate?: string;
+}
+/**
+ * Webhook tracking
+ */
+interface TransactionWebhook {
+    eventId?: string;
+    eventType?: string;
+    receivedAt?: string;
+    processedAt?: string;
+    payload?: Record<string, unknown>;
+}
+/**
+ * Reconciliation tracking
+ */
+interface TransactionReconciliation {
+    isReconciled?: boolean;
+    reconciledAt?: string;
+    reconciledBy?: string;
+    bankStatementRef?: string;
+}
+/**
+ * Transaction Document
+ *
+ * Key fields:
+ * - flow: Direction of money (inflow/outflow)
+ * - type: Category of transaction (order_purchase, refund, etc.)
+ * - amount: Gross amount in smallest unit (paisa)
+ * - fee: Platform/gateway fees deducted
+ * - tax: VAT/tax portion (informational)
+ * - net: amount - fee - tax (derived)
+ */
+interface Transaction {
+    _id: string;
+    organizationId?: string;
+    /**
+     * Flow direction: 'inflow' (money in) or 'outflow' (money out)
+     * Use this for Income/Expense classification in UI
+     */
+    flow: TransactionFlowType;
+    /**
+     * Transaction category (e.g. 'order_purchase', 'refund', 'rent', 'cogs')
+     * Note: Backend stores category in the 'type' field
+     */
+    type: TransactionCategoryType | string;
+    /** Transaction status */
+    status: TransactionStatusType | string;
+    /** Gross money that moved (in smallest unit, e.g. paisa) */
+    amount: number;
+    /** Currency code (default: 'BDT') */
+    currency?: string;
+    /** Platform/gateway fees deducted */
+    fee?: number;
+    /** VAT/tax portion (informational, for VAT reporting) */
+    tax?: number;
+    /** Net amount: amount - fee - tax */
+    net?: number;
+    /** Tax details for VAT/GST reporting */
+    taxDetails?: TransactionTaxDetails;
+    customerId?: string | null;
+    handledBy?: string | null;
+    method: PaymentMethod | string;
+    gateway?: TransactionGateway;
+    paymentDetails?: TransactionPaymentDetails;
+    /** Source model type (Order, Purchase, Manual) - polymorphic reference */
+    sourceModel?: 'Order' | 'Purchase' | 'Manual' | string;
+    /** Source document ID */
+    sourceId?: string;
+    /** Related transaction (for refunds linking to original) */
+    relatedTransactionId?: string;
+    /** Source channel: where the transaction originated */
+    source: 'web' | 'pos' | 'api';
+    /** Branch reference ID */
+    branch?: string;
+    /** Branch code for display */
+    branchCode?: string;
+    /** Commission tracking for gateway payments */
+    commission?: TransactionCommission;
+    /** Revenue splits (for marketplace use) */
+    splits?: Array<{
+        recipientId?: string;
+        recipientType?: string;
+        type?: string;
+        amount?: number;
+        status?: string;
+        paidAt?: string;
+    }>;
+    metadata?: Record<string, unknown>;
+    description?: string;
+    notes?: string;
+    idempotencyKey?: string;
+    webhook?: TransactionWebhook;
+    /** Actual transaction date (when it occurred) */
+    date?: string;
+    verifiedBy?: string;
+    verifiedAt?: string;
+    initiatedAt?: string;
+    completedAt?: string;
+    paidAt?: string;
+    failedAt?: string;
+    failureReason?: string;
+    refundedAt?: string;
+    refundedAmount?: number;
+    refundReason?: string;
+    reconciliation?: TransactionReconciliation;
+    createdAt: string;
+    updatedAt: string;
+    isPaid?: boolean;
+    amountInUnits?: number;
+}
+/**
+ * Payload to create a Manual Transaction (OpEx, CapEx, etc.)
+ * Most transactions are system-managed via order/POS flows.
+ */
+interface CreateTransactionPayload {
+    flow: TransactionFlowType;
+    type: TransactionCategoryType | string;
+    amount: number;
+    method?: PaymentMethod | string;
+    source?: 'web' | 'pos' | 'api';
+    branch?: string;
+    branchCode?: string;
+    date?: string;
+    notes?: string;
+    description?: string;
+    paymentDetails?: TransactionPaymentDetails;
+    taxDetails?: TransactionTaxDetails;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Payload to update a Transaction (limited fields)
+ * Editable correction fields (permissioned)
+ */
+interface UpdateTransactionPayload {
+    flow?: TransactionFlowType;
+    type?: TransactionCategoryType | string;
+    amount?: number;
+    fee?: number;
+    tax?: number;
+    net?: number;
+    method?: PaymentMethod | string;
+    paymentDetails?: TransactionPaymentDetails;
+    taxDetails?: TransactionTaxDetails;
+    branch?: string;
+    branchCode?: string;
+    source?: 'web' | 'pos' | 'api';
+    notes?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Payment Intent - Returned with order/POS transactions
+ */
+interface PaymentIntent {
+    id: string;
+    provider: PaymentGatewayType | string;
+    status: 'pending' | 'processing' | 'succeeded' | 'failed' | 'cancelled';
+    /** Manual payment instructions */
+    instructions?: {
+        bkash?: string;
+        nagad?: string;
+        bank?: string;
+        reference?: string;
+        note?: string;
+    };
+    /** Stripe SDK client secret */
+    clientSecret?: string | null;
+    /** Redirect URL for hosted payment pages */
+    paymentUrl?: string | null;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Financial Report Response (Profit & Loss)
+ * Uses flow-based totals: inflow (income) vs outflow (expense)
+ */
+interface FinancialReport {
+    /** Total inflow (income) */
+    income: number;
+    /** Total outflow (expense) */
+    expense: number;
+    /** Net profit (income - expense) */
+    net: number;
+    /** Breakdown by category (type field) */
+    breakdown: Record<string, number>;
+}
+/**
+ * Cash Flow Report Response
+ * Monthly trend of inflow vs outflow
+ */
+interface CashFlowReport {
+    months: Array<{
+        month: string;
+        /** Total inflow (income) for the month */
+        inflow: number;
+        /** Total outflow (expense) for the month */
+        outflow: number;
+        /** Net cash flow (inflow - outflow) */
+        net: number;
+    }>;
+}
+/**
+ * Category Report Response
+ */
+interface CategoryReport {
+    categories: Array<{
+        category: string;
+        total: number;
+        count: number;
+    }>;
+}
+/**
+ * Statement Row (for CSV/JSON export)
+ */
+interface StatementRow {
+    transactionId: string;
+    transactionDate: string | null;
+    createdAt: string | null;
+    status: string;
+    /** Flow direction: inflow/outflow */
+    flow: string;
+    /** Transaction category (type field) */
+    type: string;
+    source: string;
+    branchCode: string | null;
+    branchId: string | null;
+    method: string;
+    /** Gross amount in BDT (converted from paisa) */
+    amountBdt: number;
+    /** Fee amount in BDT */
+    feeBdt?: number;
+    /** Tax amount in BDT */
+    taxBdt?: number;
+    /** Net amount in BDT (amount - fee - tax) */
+    netBdt?: number;
+    currency: string;
+    /** Source model (Order, Purchase, Manual) */
+    sourceModel?: string;
+    /** Source document ID */
+    sourceId?: string | null;
+    orderId: string | null;
+    orderCustomerName: string | null;
+    vatInvoiceNumber: string | null;
+    vatSellerBin: string | null;
+    paymentReference: string | null;
+    narration: string | null;
+}
+/**
+ * Statement Export Response (JSON format)
+ */
+interface StatementResponse {
+    success: boolean;
+    count: number;
+    data: StatementRow[];
+}
+/**
+ * @deprecated Use TransactionFlow instead. Backend uses flow (inflow/outflow).
+ */
+declare enum TransactionType {
+    INCOME = "income",
+    EXPENSE = "expense"
+}
+
+export { type CreateTransactionPayload as C, type FinancialReport as F, type PaymentMethod as P, type StatementRow as S, TransactionFlow as T, type UpdateTransactionPayload as U, type PaymentGatewayType as a, type TransactionFlowType as b, TransactionStatus as c, type TransactionStatusType as d, TransactionCategory as e, type TransactionCategoryType as f, type TransactionSplitPayment as g, type TransactionPaymentDetails as h, type TaxType as i, type TransactionTaxDetails as j, type TransactionGateway as k, type TransactionCommission as l, type TransactionWebhook as m, type TransactionReconciliation as n, type Transaction as o, type PaymentIntent as p, type CashFlowReport as q, type CategoryReport as r, type StatementResponse as s, TransactionType as t };

package/dist/transaction-u5oaNuav.d.ts

@@ -0,0 +1,84 @@
+import { B as BaseApi } from './api-factory-B_h4RKBm.js';
+import { o as Transaction, C as CreateTransactionPayload, U as UpdateTransactionPayload, F as FinancialReport, q as CashFlowReport, r as CategoryReport, s as StatementResponse } from './transaction-BTmoHpWh.js';
+
+/**
+ * Transaction API Client
+ *
+ * Transactions track cashflow events (money in/out) across the system.
+ * Used by: Orders, POS, Inventory, CRM, HRM, and manual entries.
+ *
+ * CRUD (via BaseApi):
+ * - getAll(params) - List transactions
+ * - getById(id) - Get transaction
+ * - create(payload) - Create manual transaction (staff only)
+ * - update(id, payload) - Update transaction (limited fields)
+ * - delete(id) - Delete transaction (admin/superadmin only)
+ *
+ * Reports:
+ * - getProfitLoss(params) - P&L statement
+ * - getCashFlow(params) - Monthly trend
+ * - getCategoryReport(params) - Category breakdown
+ *
+ * Export:
+ * - getStatement(params) - CSV/JSON export for accountants
+ */
+
+/**
+ * Statement Query Params
+ */
+interface StatementParams {
+    startDate?: string;
+    endDate?: string;
+    branchId?: string;
+    source?: 'web' | 'pos' | 'api';
+    status?: string;
+    format?: 'csv' | 'json';
+    [key: string]: unknown;
+}
+/**
+ * Report Query Params
+ */
+interface ReportParams {
+    startDate?: string;
+    endDate?: string;
+    branchId?: string;
+    [key: string]: unknown;
+}
+interface CashFlowParams {
+    months?: number;
+    branchId?: string;
+    [key: string]: unknown;
+}
+interface CategoryParams extends ReportParams {
+    flow?: 'inflow' | 'outflow';
+    limit?: number;
+}
+declare class TransactionApi extends BaseApi<Transaction, CreateTransactionPayload, UpdateTransactionPayload> {
+    /**
+     * Get Profit & Loss Report
+     * Returns income (inflow), expenses (outflow), and net profit for a date range
+     */
+    getProfitLoss(params?: ReportParams, options?: {}): Promise<FinancialReport>;
+    /**
+     * Get Cash Flow Report
+     * Returns monthly inflow, outflow, and net trend
+     */
+    getCashFlow(params?: CashFlowParams, options?: {}): Promise<CashFlowReport>;
+    /**
+     * Get Category Breakdown
+     * Returns top spending/income categories for a date range
+     * Filter by flow='inflow' for income categories, flow='outflow' for expense categories
+     */
+    getCategoryReport(params?: CategoryParams, options?: {}): Promise<CategoryReport>;
+    /**
+     * Get Statement Export
+     * Accountant-friendly export with branch + VAT invoice references
+     *
+     * @param params.format - 'csv' (default) or 'json'
+     * @returns CSV blob (format=csv) or StatementResponse (format=json)
+     */
+    getStatement(params?: StatementParams, options?: {}): Promise<Blob | StatementResponse>;
+}
+declare const transactionApi: TransactionApi;
+
+export { type CashFlowParams as C, type ReportParams as R, type StatementParams as S, TransactionApi as T, type CategoryParams as a, transactionApi as t };

package/dist/transfer-7SYSH3RG.js

@@ -0,0 +1,5 @@
+export { TransferApi, transferApi } from './chunk-FA7QFJ2G.js';
+import './chunk-I5TIKUIQ.js';
+import './chunk-VR36QVX2.js';
+//# sourceMappingURL=transfer-7SYSH3RG.js.map
+//# sourceMappingURL=transfer-7SYSH3RG.js.map

package/dist/transfer-7SYSH3RG.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"transfer-7SYSH3RG.js"}