diff --git a/shared/sdk-ts/src/reports.ts b/shared/sdk-ts/src/reports.ts
index 03b7a769a..08c2cb1bd 100644
--- a/shared/sdk-ts/src/reports.ts
+++ b/shared/sdk-ts/src/reports.ts
@@ -1,278 +1,2 @@
-import type { OpArgType } from 'openapi-typescript-fetch';
-import type { ApiFetcher } from './fetch-utils';
-import { paths } from './schema';
-import { OpForPath, OpQueryParams, OpResponseBodyTable } from './utils';
-
-export const REPORTS_ROUTES = {
-  BALANCE_SHEET: '/api/reports/balance-sheet',
-  PURCHASES_BY_ITEMS: '/api/reports/purchases-by-items',
-  CUSTOMER_BALANCE_SUMMARY: '/api/reports/customer-balance-summary',
-  VENDOR_BALANCE_SUMMARY: '/api/reports/vendor-balance-summary',
-  SALES_BY_ITEMS: '/api/reports/sales-by-items',
-  GENERAL_LEDGER: '/api/reports/general-ledger',
-  TRIAL_BALANCE_SHEET: '/api/reports/trial-balance-sheet',
-  TRANSACTIONS_BY_VENDORS: '/api/reports/transactions-by-vendors',
-  TRANSACTIONS_BY_CUSTOMERS: '/api/reports/transactions-by-customers',
-  TRANSACTIONS_BY_REFERENCE: '/api/reports/transactions-by-reference',
-  RECEIVABLE_AGING_SUMMARY: '/api/reports/receivable-aging-summary',
-  PAYABLE_AGING_SUMMARY: '/api/reports/payable-aging-summary',
-  INVENTORY_ITEM_DETAILS: '/api/reports/inventory-item-details',
-  INVENTORY_VALUATION: '/api/reports/inventory-valuation',
-  SALES_TAX_LIABILITY_SUMMARY: '/api/reports/sales-tax-liability-summary',
-  JOURNAL: '/api/reports/journal',
-  PROFIT_LOSS_SHEET: '/api/reports/profit-loss-sheet',
-  CASHFLOW_STATEMENT: '/api/reports/cashflow-statement',
-} as const satisfies Record<string, keyof paths>;
-
-type Route = (typeof REPORTS_ROUTES)[keyof typeof REPORTS_ROUTES];
-
-function createReportFetcher<R extends Route>(
-  fetcher: ApiFetcher,
-  route: R
-): (
-  query: OpQueryParams<OpForPath<R, 'get'>>
-) => Promise<OpResponseBodyTable<OpForPath<R, 'get'>>> {
-  type Op = OpForPath<R, 'get'>;
-  type Query = OpQueryParams<Op>;
-  type Arg = OpArgType<Op>;
-  type Table = OpResponseBodyTable<Op>;
-  const get = fetcher.path(route).method('get').create();
-  return async (query: Query): Promise<Table> => {
-    const { data } = await get(query as Arg);
-    return data as Table;
-  };
-}
-
-export type BalanceSheetTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.BALANCE_SHEET, 'get'>
->;
-export type BalanceSheetTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.BALANCE_SHEET, 'get'>
->;
-export async function fetchBalanceSheetTable(
-  fetcher: ApiFetcher,
-  query: BalanceSheetTableQuery
-): Promise<BalanceSheetTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.BALANCE_SHEET)(query);
-}
-
-export type TrialBalanceSheetTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.TRIAL_BALANCE_SHEET, 'get'>
->;
-export type TrialBalanceSheetTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.TRIAL_BALANCE_SHEET, 'get'>
->;
-export async function fetchTrialBalanceSheetTable(
-  fetcher: ApiFetcher,
-  query: TrialBalanceSheetTableQuery
-): Promise<TrialBalanceSheetTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.TRIAL_BALANCE_SHEET)(query);
-}
-
-export type ProfitLossSheetTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.PROFIT_LOSS_SHEET, 'get'>
->;
-export type ProfitLossSheetTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.PROFIT_LOSS_SHEET, 'get'>
->;
-export async function fetchProfitLossSheetTable(
-  fetcher: ApiFetcher,
-  query: ProfitLossSheetTableQuery
-): Promise<ProfitLossSheetTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.PROFIT_LOSS_SHEET)(query);
-}
-
-export type CashflowStatementTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.CASHFLOW_STATEMENT, 'get'>
->;
-export type CashflowStatementTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.CASHFLOW_STATEMENT, 'get'>
->;
-export async function fetchCashflowStatementTable(
-  fetcher: ApiFetcher,
-  query: CashflowStatementTableQuery
-): Promise<CashflowStatementTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.CASHFLOW_STATEMENT)(query);
-}
-
-export type GeneralLedgerTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.GENERAL_LEDGER, 'get'>
->;
-export type GeneralLedgerTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.GENERAL_LEDGER, 'get'>
->;
-export async function fetchGeneralLedgerTable(
-  fetcher: ApiFetcher,
-  query: GeneralLedgerTableQuery
-): Promise<GeneralLedgerTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.GENERAL_LEDGER)(query);
-}
-
-export type JournalTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.JOURNAL, 'get'>
->;
-export type JournalTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.JOURNAL, 'get'>
->;
-export async function fetchJournalTable(
-  fetcher: ApiFetcher,
-  query: JournalTableQuery
-): Promise<JournalTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.JOURNAL)(query);
-}
-
-export type ReceivableAgingSummaryTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.RECEIVABLE_AGING_SUMMARY, 'get'>
->;
-export type ReceivableAgingSummaryTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.RECEIVABLE_AGING_SUMMARY, 'get'>
->;
-export async function fetchReceivableAgingSummaryTable(
-  fetcher: ApiFetcher,
-  query: ReceivableAgingSummaryTableQuery
-): Promise<ReceivableAgingSummaryTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.RECEIVABLE_AGING_SUMMARY)(query);
-}
-
-export type PayableAgingSummaryTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.PAYABLE_AGING_SUMMARY, 'get'>
->;
-export type PayableAgingSummaryTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.PAYABLE_AGING_SUMMARY, 'get'>
->;
-export async function fetchPayableAgingSummaryTable(
-  fetcher: ApiFetcher,
-  query: PayableAgingSummaryTableQuery
-): Promise<PayableAgingSummaryTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.PAYABLE_AGING_SUMMARY)(query);
-}
-
-export type CustomerBalanceSummaryTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.CUSTOMER_BALANCE_SUMMARY, 'get'>
->;
-export type CustomerBalanceSummaryTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.CUSTOMER_BALANCE_SUMMARY, 'get'>
->;
-export async function fetchCustomerBalanceSummaryTable(
-  fetcher: ApiFetcher,
-  query: CustomerBalanceSummaryTableQuery
-): Promise<CustomerBalanceSummaryTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.CUSTOMER_BALANCE_SUMMARY)(query);
-}
-
-export type VendorBalanceSummaryTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.VENDOR_BALANCE_SUMMARY, 'get'>
->;
-export type VendorBalanceSummaryTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.VENDOR_BALANCE_SUMMARY, 'get'>
->;
-export async function fetchVendorBalanceSummaryTable(
-  fetcher: ApiFetcher,
-  query: VendorBalanceSummaryTableQuery
-): Promise<VendorBalanceSummaryTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.VENDOR_BALANCE_SUMMARY)(query);
-}
-
-export type TransactionsByCustomersTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.TRANSACTIONS_BY_CUSTOMERS, 'get'>
->;
-export type TransactionsByCustomersTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.TRANSACTIONS_BY_CUSTOMERS, 'get'>
->;
-export async function fetchTransactionsByCustomersTable(
-  fetcher: ApiFetcher,
-  query: TransactionsByCustomersTableQuery
-): Promise<TransactionsByCustomersTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.TRANSACTIONS_BY_CUSTOMERS)(query);
-}
-
-export type TransactionsByVendorsTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.TRANSACTIONS_BY_VENDORS, 'get'>
->;
-export type TransactionsByVendorsTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.TRANSACTIONS_BY_VENDORS, 'get'>
->;
-export async function fetchTransactionsByVendorsTable(
-  fetcher: ApiFetcher,
-  query: TransactionsByVendorsTableQuery
-): Promise<TransactionsByVendorsTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.TRANSACTIONS_BY_VENDORS)(query);
-}
-
-export type SalesByItemsTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.SALES_BY_ITEMS, 'get'>
->;
-export type SalesByItemsTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.SALES_BY_ITEMS, 'get'>
->;
-export async function fetchSalesByItemsTable(
-  fetcher: ApiFetcher,
-  query: SalesByItemsTableQuery
-): Promise<SalesByItemsTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.SALES_BY_ITEMS)(query);
-}
-
-export type PurchasesByItemsTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.PURCHASES_BY_ITEMS, 'get'>
->;
-export type PurchasesByItemsTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.PURCHASES_BY_ITEMS, 'get'>
->;
-export async function fetchPurchasesByItemsTable(
-  fetcher: ApiFetcher,
-  query: PurchasesByItemsTableQuery
-): Promise<PurchasesByItemsTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.PURCHASES_BY_ITEMS)(query);
-}
-
-export type InventoryValuationTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.INVENTORY_VALUATION, 'get'>
->;
-export type InventoryValuationTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.INVENTORY_VALUATION, 'get'>
->;
-export async function fetchInventoryValuationTable(
-  fetcher: ApiFetcher,
-  query: InventoryValuationTableQuery
-): Promise<InventoryValuationTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.INVENTORY_VALUATION)(query);
-}
-
-export type InventoryItemDetailsTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.INVENTORY_ITEM_DETAILS, 'get'>
->;
-export type InventoryItemDetailsTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.INVENTORY_ITEM_DETAILS, 'get'>
->;
-export async function fetchInventoryItemDetailsTable(
-  fetcher: ApiFetcher,
-  query: InventoryItemDetailsTableQuery
-): Promise<InventoryItemDetailsTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.INVENTORY_ITEM_DETAILS)(query);
-}
-
-export type SalesTaxLiabilitySummaryTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.SALES_TAX_LIABILITY_SUMMARY, 'get'>
->;
-export type SalesTaxLiabilitySummaryTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.SALES_TAX_LIABILITY_SUMMARY, 'get'>
->;
-export async function fetchSalesTaxLiabilitySummaryTable(
-  fetcher: ApiFetcher,
-  query: SalesTaxLiabilitySummaryTableQuery
-): Promise<SalesTaxLiabilitySummaryTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.SALES_TAX_LIABILITY_SUMMARY)(query);
-}
-
-export type TransactionsByReferenceTableQuery = OpQueryParams<
-  OpForPath<typeof REPORTS_ROUTES.TRANSACTIONS_BY_REFERENCE, 'get'>
->;
-export type TransactionsByReferenceTableResponse = OpResponseBodyTable<
-  OpForPath<typeof REPORTS_ROUTES.TRANSACTIONS_BY_REFERENCE, 'get'>
->;
-export async function fetchTransactionsByReferenceTable(
-  fetcher: ApiFetcher,
-  query: TransactionsByReferenceTableQuery
-): Promise<TransactionsByReferenceTableResponse> {
-  return createReportFetcher(fetcher, REPORTS_ROUTES.TRANSACTIONS_BY_REFERENCE)(query);
-}
+// Re-export all reports from the new modular structure for backward compatibility
+export * from './reports/index';
diff --git a/shared/sdk-ts/src/reports/balance-sheet.ts b/shared/sdk-ts/src/reports/balance-sheet.ts
new file mode 100644
index 000000000..8b26f99f1
--- /dev/null
+++ b/shared/sdk-ts/src/reports/balance-sheet.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const BALANCE_SHEET_ROUTE = '/api/reports/balance-sheet' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof BALANCE_SHEET_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type BalanceSheetTableQuery = OpQueryParams<Op>;
+export type BalanceSheetTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchBalanceSheetTable(
+  fetcher: ApiFetcher,
+  query: BalanceSheetTableQuery
+): Promise<BalanceSheetTableResponse> {
+  const get = fetcher.path(BALANCE_SHEET_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as BalanceSheetTableResponse;
+}
+
+// JSON format - Note: BalanceSheet only has table format in schema
+// Using type assertion for JSON format compatibility
+export type BalanceSheetJsonQuery = OpQueryParams<Op>;
+export type BalanceSheetJsonResponse = OpResponseBody<Op>;
+
+export async function fetchBalanceSheetJson(
+  fetcher: ApiFetcher,
+  query: BalanceSheetJsonQuery
+): Promise<BalanceSheetJsonResponse> {
+  const get = fetcher.path(BALANCE_SHEET_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as BalanceSheetJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type BalanceSheetCsvQuery = OpQueryParams<Op>;
+export type BalanceSheetCsvResponse = Blob;
+
+export async function fetchBalanceSheetCsv(
+  fetcher: ApiFetcher,
+  query: BalanceSheetCsvQuery
+): Promise<BalanceSheetCsvResponse> {
+  const get = fetcher.path(BALANCE_SHEET_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as BalanceSheetCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type BalanceSheetXlsxQuery = OpQueryParams<Op>;
+export type BalanceSheetXlsxResponse = Blob;
+
+export async function fetchBalanceSheetXlsx(
+  fetcher: ApiFetcher,
+  query: BalanceSheetXlsxQuery
+): Promise<BalanceSheetXlsxResponse> {
+  const get = fetcher.path(BALANCE_SHEET_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as BalanceSheetXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type BalanceSheetPdfQuery = OpQueryParams<Op>;
+export type BalanceSheetPdfResponse = Blob;
+
+export async function fetchBalanceSheetPdf(
+  fetcher: ApiFetcher,
+  query: BalanceSheetPdfQuery
+): Promise<BalanceSheetPdfResponse> {
+  const get = fetcher.path(BALANCE_SHEET_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as BalanceSheetPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/cashflow.ts b/shared/sdk-ts/src/reports/cashflow.ts
new file mode 100644
index 000000000..c66c6d490
--- /dev/null
+++ b/shared/sdk-ts/src/reports/cashflow.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const CASHFLOW_ROUTE = '/api/reports/cashflow-statement' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof CASHFLOW_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type CashflowStatementTableQuery = OpQueryParams<Op>;
+export type CashflowStatementTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchCashflowStatementTable(
+  fetcher: ApiFetcher,
+  query: CashflowStatementTableQuery
+): Promise<CashflowStatementTableResponse> {
+  const get = fetcher.path(CASHFLOW_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as CashflowStatementTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type CashflowStatementJsonQuery = OpQueryParams<Op>;
+export type CashflowStatementJsonResponse = OpResponseBody<Op>;
+
+export async function fetchCashflowStatementJson(
+  fetcher: ApiFetcher,
+  query: CashflowStatementJsonQuery
+): Promise<CashflowStatementJsonResponse> {
+  const get = fetcher.path(CASHFLOW_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as CashflowStatementJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type CashflowStatementCsvQuery = OpQueryParams<Op>;
+export type CashflowStatementCsvResponse = Blob;
+
+export async function fetchCashflowStatementCsv(
+  fetcher: ApiFetcher,
+  query: CashflowStatementCsvQuery
+): Promise<CashflowStatementCsvResponse> {
+  const get = fetcher.path(CASHFLOW_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as CashflowStatementCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type CashflowStatementXlsxQuery = OpQueryParams<Op>;
+export type CashflowStatementXlsxResponse = Blob;
+
+export async function fetchCashflowStatementXlsx(
+  fetcher: ApiFetcher,
+  query: CashflowStatementXlsxQuery
+): Promise<CashflowStatementXlsxResponse> {
+  const get = fetcher.path(CASHFLOW_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as CashflowStatementXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type CashflowStatementPdfQuery = OpQueryParams<Op>;
+export type CashflowStatementPdfResponse = Blob;
+
+export async function fetchCashflowStatementPdf(
+  fetcher: ApiFetcher,
+  query: CashflowStatementPdfQuery
+): Promise<CashflowStatementPdfResponse> {
+  const get = fetcher.path(CASHFLOW_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as CashflowStatementPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/customer-balance.ts b/shared/sdk-ts/src/reports/customer-balance.ts
new file mode 100644
index 000000000..4ffc5bd24
--- /dev/null
+++ b/shared/sdk-ts/src/reports/customer-balance.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const CUSTOMER_BALANCE_ROUTE = '/api/reports/customer-balance-summary' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof CUSTOMER_BALANCE_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type CustomerBalanceTableQuery = OpQueryParams<Op>;
+export type CustomerBalanceTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchCustomerBalanceTable(
+  fetcher: ApiFetcher,
+  query: CustomerBalanceTableQuery
+): Promise<CustomerBalanceTableResponse> {
+  const get = fetcher.path(CUSTOMER_BALANCE_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as CustomerBalanceTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type CustomerBalanceJsonQuery = OpQueryParams<Op>;
+export type CustomerBalanceJsonResponse = OpResponseBody<Op>;
+
+export async function fetchCustomerBalanceJson(
+  fetcher: ApiFetcher,
+  query: CustomerBalanceJsonQuery
+): Promise<CustomerBalanceJsonResponse> {
+  const get = fetcher.path(CUSTOMER_BALANCE_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as CustomerBalanceJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type CustomerBalanceCsvQuery = OpQueryParams<Op>;
+export type CustomerBalanceCsvResponse = Blob;
+
+export async function fetchCustomerBalanceCsv(
+  fetcher: ApiFetcher,
+  query: CustomerBalanceCsvQuery
+): Promise<CustomerBalanceCsvResponse> {
+  const get = fetcher.path(CUSTOMER_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as CustomerBalanceCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type CustomerBalanceXlsxQuery = OpQueryParams<Op>;
+export type CustomerBalanceXlsxResponse = Blob;
+
+export async function fetchCustomerBalanceXlsx(
+  fetcher: ApiFetcher,
+  query: CustomerBalanceXlsxQuery
+): Promise<CustomerBalanceXlsxResponse> {
+  const get = fetcher.path(CUSTOMER_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as CustomerBalanceXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type CustomerBalancePdfQuery = OpQueryParams<Op>;
+export type CustomerBalancePdfResponse = Blob;
+
+export async function fetchCustomerBalancePdf(
+  fetcher: ApiFetcher,
+  query: CustomerBalancePdfQuery
+): Promise<CustomerBalancePdfResponse> {
+  const get = fetcher.path(CUSTOMER_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as CustomerBalancePdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/general-ledger.ts b/shared/sdk-ts/src/reports/general-ledger.ts
new file mode 100644
index 000000000..9d3358a10
--- /dev/null
+++ b/shared/sdk-ts/src/reports/general-ledger.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const GENERAL_LEDGER_ROUTE = '/api/reports/general-ledger' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof GENERAL_LEDGER_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type GeneralLedgerTableQuery = OpQueryParams<Op>;
+export type GeneralLedgerTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchGeneralLedgerTable(
+  fetcher: ApiFetcher,
+  query: GeneralLedgerTableQuery
+): Promise<GeneralLedgerTableResponse> {
+  const get = fetcher.path(GENERAL_LEDGER_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as GeneralLedgerTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type GeneralLedgerJsonQuery = OpQueryParams<Op>;
+export type GeneralLedgerJsonResponse = OpResponseBody<Op>;
+
+export async function fetchGeneralLedgerJson(
+  fetcher: ApiFetcher,
+  query: GeneralLedgerJsonQuery
+): Promise<GeneralLedgerJsonResponse> {
+  const get = fetcher.path(GENERAL_LEDGER_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as GeneralLedgerJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type GeneralLedgerCsvQuery = OpQueryParams<Op>;
+export type GeneralLedgerCsvResponse = Blob;
+
+export async function fetchGeneralLedgerCsv(
+  fetcher: ApiFetcher,
+  query: GeneralLedgerCsvQuery
+): Promise<GeneralLedgerCsvResponse> {
+  const get = fetcher.path(GENERAL_LEDGER_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as GeneralLedgerCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type GeneralLedgerXlsxQuery = OpQueryParams<Op>;
+export type GeneralLedgerXlsxResponse = Blob;
+
+export async function fetchGeneralLedgerXlsx(
+  fetcher: ApiFetcher,
+  query: GeneralLedgerXlsxQuery
+): Promise<GeneralLedgerXlsxResponse> {
+  const get = fetcher.path(GENERAL_LEDGER_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as GeneralLedgerXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type GeneralLedgerPdfQuery = OpQueryParams<Op>;
+export type GeneralLedgerPdfResponse = Blob;
+
+export async function fetchGeneralLedgerPdf(
+  fetcher: ApiFetcher,
+  query: GeneralLedgerPdfQuery
+): Promise<GeneralLedgerPdfResponse> {
+  const get = fetcher.path(GENERAL_LEDGER_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as GeneralLedgerPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/index.ts b/shared/sdk-ts/src/reports/index.ts
new file mode 100644
index 000000000..77f28bbba
--- /dev/null
+++ b/shared/sdk-ts/src/reports/index.ts
@@ -0,0 +1,19 @@
+// Re-export all report modules
+export * from './balance-sheet';
+export * from './trial-balance';
+export * from './profit-loss';
+export * from './cashflow';
+export * from './general-ledger';
+export * from './journal';
+export * from './receivable-aging';
+export * from './payable-aging';
+export * from './customer-balance';
+export * from './vendor-balance';
+export * from './transactions-customers';
+export * from './transactions-vendors';
+export * from './sales-by-items';
+export * from './purchases-by-items';
+export * from './inventory-valuation';
+export * from './inventory-details';
+export * from './sales-tax-liability';
+export * from './transactions-reference';
diff --git a/shared/sdk-ts/src/reports/inventory-details.ts b/shared/sdk-ts/src/reports/inventory-details.ts
new file mode 100644
index 000000000..2a9e4037f
--- /dev/null
+++ b/shared/sdk-ts/src/reports/inventory-details.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const INVENTORY_DETAILS_ROUTE = '/api/reports/inventory-item-details' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof INVENTORY_DETAILS_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type InventoryItemDetailsTableQuery = OpQueryParams<Op>;
+export type InventoryItemDetailsTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchInventoryItemDetailsTable(
+  fetcher: ApiFetcher,
+  query: InventoryItemDetailsTableQuery
+): Promise<InventoryItemDetailsTableResponse> {
+  const get = fetcher.path(INVENTORY_DETAILS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as InventoryItemDetailsTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type InventoryItemDetailsJsonQuery = OpQueryParams<Op>;
+export type InventoryItemDetailsJsonResponse = OpResponseBody<Op>;
+
+export async function fetchInventoryItemDetailsJson(
+  fetcher: ApiFetcher,
+  query: InventoryItemDetailsJsonQuery
+): Promise<InventoryItemDetailsJsonResponse> {
+  const get = fetcher.path(INVENTORY_DETAILS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as InventoryItemDetailsJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type InventoryItemDetailsCsvQuery = OpQueryParams<Op>;
+export type InventoryItemDetailsCsvResponse = Blob;
+
+export async function fetchInventoryItemDetailsCsv(
+  fetcher: ApiFetcher,
+  query: InventoryItemDetailsCsvQuery
+): Promise<InventoryItemDetailsCsvResponse> {
+  const get = fetcher.path(INVENTORY_DETAILS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as InventoryItemDetailsCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type InventoryItemDetailsXlsxQuery = OpQueryParams<Op>;
+export type InventoryItemDetailsXlsxResponse = Blob;
+
+export async function fetchInventoryItemDetailsXlsx(
+  fetcher: ApiFetcher,
+  query: InventoryItemDetailsXlsxQuery
+): Promise<InventoryItemDetailsXlsxResponse> {
+  const get = fetcher.path(INVENTORY_DETAILS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as InventoryItemDetailsXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type InventoryItemDetailsPdfQuery = OpQueryParams<Op>;
+export type InventoryItemDetailsPdfResponse = Blob;
+
+export async function fetchInventoryItemDetailsPdf(
+  fetcher: ApiFetcher,
+  query: InventoryItemDetailsPdfQuery
+): Promise<InventoryItemDetailsPdfResponse> {
+  const get = fetcher.path(INVENTORY_DETAILS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as InventoryItemDetailsPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/inventory-valuation.ts b/shared/sdk-ts/src/reports/inventory-valuation.ts
new file mode 100644
index 000000000..c05f30752
--- /dev/null
+++ b/shared/sdk-ts/src/reports/inventory-valuation.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const INVENTORY_VALUATION_ROUTE = '/api/reports/inventory-valuation' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof INVENTORY_VALUATION_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type InventoryValuationTableQuery = OpQueryParams<Op>;
+export type InventoryValuationTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchInventoryValuationTable(
+  fetcher: ApiFetcher,
+  query: InventoryValuationTableQuery
+): Promise<InventoryValuationTableResponse> {
+  const get = fetcher.path(INVENTORY_VALUATION_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as InventoryValuationTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type InventoryValuationJsonQuery = OpQueryParams<Op>;
+export type InventoryValuationJsonResponse = OpResponseBody<Op>;
+
+export async function fetchInventoryValuationJson(
+  fetcher: ApiFetcher,
+  query: InventoryValuationJsonQuery
+): Promise<InventoryValuationJsonResponse> {
+  const get = fetcher.path(INVENTORY_VALUATION_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as InventoryValuationJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type InventoryValuationCsvQuery = OpQueryParams<Op>;
+export type InventoryValuationCsvResponse = Blob;
+
+export async function fetchInventoryValuationCsv(
+  fetcher: ApiFetcher,
+  query: InventoryValuationCsvQuery
+): Promise<InventoryValuationCsvResponse> {
+  const get = fetcher.path(INVENTORY_VALUATION_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as InventoryValuationCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type InventoryValuationXlsxQuery = OpQueryParams<Op>;
+export type InventoryValuationXlsxResponse = Blob;
+
+export async function fetchInventoryValuationXlsx(
+  fetcher: ApiFetcher,
+  query: InventoryValuationXlsxQuery
+): Promise<InventoryValuationXlsxResponse> {
+  const get = fetcher.path(INVENTORY_VALUATION_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as InventoryValuationXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type InventoryValuationPdfQuery = OpQueryParams<Op>;
+export type InventoryValuationPdfResponse = Blob;
+
+export async function fetchInventoryValuationPdf(
+  fetcher: ApiFetcher,
+  query: InventoryValuationPdfQuery
+): Promise<InventoryValuationPdfResponse> {
+  const get = fetcher.path(INVENTORY_VALUATION_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as InventoryValuationPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/journal.ts b/shared/sdk-ts/src/reports/journal.ts
new file mode 100644
index 000000000..f0d7e0e16
--- /dev/null
+++ b/shared/sdk-ts/src/reports/journal.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const JOURNAL_ROUTE = '/api/reports/journal' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof JOURNAL_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type JournalTableQuery = OpQueryParams<Op>;
+export type JournalTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchJournalTable(
+  fetcher: ApiFetcher,
+  query: JournalTableQuery
+): Promise<JournalTableResponse> {
+  const get = fetcher.path(JOURNAL_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as JournalTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type JournalJsonQuery = OpQueryParams<Op>;
+export type JournalJsonResponse = OpResponseBody<Op>;
+
+export async function fetchJournalJson(
+  fetcher: ApiFetcher,
+  query: JournalJsonQuery
+): Promise<JournalJsonResponse> {
+  const get = fetcher.path(JOURNAL_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as JournalJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type JournalCsvQuery = OpQueryParams<Op>;
+export type JournalCsvResponse = Blob;
+
+export async function fetchJournalCsv(
+  fetcher: ApiFetcher,
+  query: JournalCsvQuery
+): Promise<JournalCsvResponse> {
+  const get = fetcher.path(JOURNAL_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as JournalCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type JournalXlsxQuery = OpQueryParams<Op>;
+export type JournalXlsxResponse = Blob;
+
+export async function fetchJournalXlsx(
+  fetcher: ApiFetcher,
+  query: JournalXlsxQuery
+): Promise<JournalXlsxResponse> {
+  const get = fetcher.path(JOURNAL_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as JournalXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type JournalPdfQuery = OpQueryParams<Op>;
+export type JournalPdfResponse = Blob;
+
+export async function fetchJournalPdf(
+  fetcher: ApiFetcher,
+  query: JournalPdfQuery
+): Promise<JournalPdfResponse> {
+  const get = fetcher.path(JOURNAL_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as JournalPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/payable-aging.ts b/shared/sdk-ts/src/reports/payable-aging.ts
new file mode 100644
index 000000000..508fe3eaf
--- /dev/null
+++ b/shared/sdk-ts/src/reports/payable-aging.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const PAYABLE_AGING_ROUTE = '/api/reports/payable-aging-summary' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof PAYABLE_AGING_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type PayableAgingTableQuery = OpQueryParams<Op>;
+export type PayableAgingTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchPayableAgingTable(
+  fetcher: ApiFetcher,
+  query: PayableAgingTableQuery
+): Promise<PayableAgingTableResponse> {
+  const get = fetcher.path(PAYABLE_AGING_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as PayableAgingTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type PayableAgingJsonQuery = OpQueryParams<Op>;
+export type PayableAgingJsonResponse = OpResponseBody<Op>;
+
+export async function fetchPayableAgingJson(
+  fetcher: ApiFetcher,
+  query: PayableAgingJsonQuery
+): Promise<PayableAgingJsonResponse> {
+  const get = fetcher.path(PAYABLE_AGING_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as PayableAgingJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type PayableAgingCsvQuery = OpQueryParams<Op>;
+export type PayableAgingCsvResponse = Blob;
+
+export async function fetchPayableAgingCsv(
+  fetcher: ApiFetcher,
+  query: PayableAgingCsvQuery
+): Promise<PayableAgingCsvResponse> {
+  const get = fetcher.path(PAYABLE_AGING_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as PayableAgingCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type PayableAgingXlsxQuery = OpQueryParams<Op>;
+export type PayableAgingXlsxResponse = Blob;
+
+export async function fetchPayableAgingXlsx(
+  fetcher: ApiFetcher,
+  query: PayableAgingXlsxQuery
+): Promise<PayableAgingXlsxResponse> {
+  const get = fetcher.path(PAYABLE_AGING_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as PayableAgingXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type PayableAgingPdfQuery = OpQueryParams<Op>;
+export type PayableAgingPdfResponse = Blob;
+
+export async function fetchPayableAgingPdf(
+  fetcher: ApiFetcher,
+  query: PayableAgingPdfQuery
+): Promise<PayableAgingPdfResponse> {
+  const get = fetcher.path(PAYABLE_AGING_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as PayableAgingPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/profit-loss.ts b/shared/sdk-ts/src/reports/profit-loss.ts
new file mode 100644
index 000000000..446b530c9
--- /dev/null
+++ b/shared/sdk-ts/src/reports/profit-loss.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const PROFIT_LOSS_ROUTE = '/api/reports/profit-loss-sheet' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof PROFIT_LOSS_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type ProfitLossTableQuery = OpQueryParams<Op>;
+export type ProfitLossTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchProfitLossTable(
+  fetcher: ApiFetcher,
+  query: ProfitLossTableQuery
+): Promise<ProfitLossTableResponse> {
+  const get = fetcher.path(PROFIT_LOSS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as ProfitLossTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type ProfitLossJsonQuery = OpQueryParams<Op>;
+export type ProfitLossJsonResponse = OpResponseBody<Op>;
+
+export async function fetchProfitLossJson(
+  fetcher: ApiFetcher,
+  query: ProfitLossJsonQuery
+): Promise<ProfitLossJsonResponse> {
+  const get = fetcher.path(PROFIT_LOSS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as ProfitLossJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type ProfitLossCsvQuery = OpQueryParams<Op>;
+export type ProfitLossCsvResponse = Blob;
+
+export async function fetchProfitLossCsv(
+  fetcher: ApiFetcher,
+  query: ProfitLossCsvQuery
+): Promise<ProfitLossCsvResponse> {
+  const get = fetcher.path(PROFIT_LOSS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as ProfitLossCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type ProfitLossXlsxQuery = OpQueryParams<Op>;
+export type ProfitLossXlsxResponse = Blob;
+
+export async function fetchProfitLossXlsx(
+  fetcher: ApiFetcher,
+  query: ProfitLossXlsxQuery
+): Promise<ProfitLossXlsxResponse> {
+  const get = fetcher.path(PROFIT_LOSS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as ProfitLossXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type ProfitLossPdfQuery = OpQueryParams<Op>;
+export type ProfitLossPdfResponse = Blob;
+
+export async function fetchProfitLossPdf(
+  fetcher: ApiFetcher,
+  query: ProfitLossPdfQuery
+): Promise<ProfitLossPdfResponse> {
+  const get = fetcher.path(PROFIT_LOSS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as ProfitLossPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/purchases-by-items.ts b/shared/sdk-ts/src/reports/purchases-by-items.ts
new file mode 100644
index 000000000..3bdc8fc2f
--- /dev/null
+++ b/shared/sdk-ts/src/reports/purchases-by-items.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const PURCHASES_BY_ITEMS_ROUTE = '/api/reports/purchases-by-items' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof PURCHASES_BY_ITEMS_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type PurchasesByItemsTableQuery = OpQueryParams<Op>;
+export type PurchasesByItemsTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchPurchasesByItemsTable(
+  fetcher: ApiFetcher,
+  query: PurchasesByItemsTableQuery
+): Promise<PurchasesByItemsTableResponse> {
+  const get = fetcher.path(PURCHASES_BY_ITEMS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as PurchasesByItemsTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type PurchasesByItemsJsonQuery = OpQueryParams<Op>;
+export type PurchasesByItemsJsonResponse = OpResponseBody<Op>;
+
+export async function fetchPurchasesByItemsJson(
+  fetcher: ApiFetcher,
+  query: PurchasesByItemsJsonQuery
+): Promise<PurchasesByItemsJsonResponse> {
+  const get = fetcher.path(PURCHASES_BY_ITEMS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as PurchasesByItemsJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type PurchasesByItemsCsvQuery = OpQueryParams<Op>;
+export type PurchasesByItemsCsvResponse = Blob;
+
+export async function fetchPurchasesByItemsCsv(
+  fetcher: ApiFetcher,
+  query: PurchasesByItemsCsvQuery
+): Promise<PurchasesByItemsCsvResponse> {
+  const get = fetcher.path(PURCHASES_BY_ITEMS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as PurchasesByItemsCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type PurchasesByItemsXlsxQuery = OpQueryParams<Op>;
+export type PurchasesByItemsXlsxResponse = Blob;
+
+export async function fetchPurchasesByItemsXlsx(
+  fetcher: ApiFetcher,
+  query: PurchasesByItemsXlsxQuery
+): Promise<PurchasesByItemsXlsxResponse> {
+  const get = fetcher.path(PURCHASES_BY_ITEMS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as PurchasesByItemsXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type PurchasesByItemsPdfQuery = OpQueryParams<Op>;
+export type PurchasesByItemsPdfResponse = Blob;
+
+export async function fetchPurchasesByItemsPdf(
+  fetcher: ApiFetcher,
+  query: PurchasesByItemsPdfQuery
+): Promise<PurchasesByItemsPdfResponse> {
+  const get = fetcher.path(PURCHASES_BY_ITEMS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as PurchasesByItemsPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/receivable-aging.ts b/shared/sdk-ts/src/reports/receivable-aging.ts
new file mode 100644
index 000000000..8b5b4f1dc
--- /dev/null
+++ b/shared/sdk-ts/src/reports/receivable-aging.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const RECEIVABLE_AGING_ROUTE = '/api/reports/receivable-aging-summary' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof RECEIVABLE_AGING_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type ReceivableAgingTableQuery = OpQueryParams<Op>;
+export type ReceivableAgingTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchReceivableAgingTable(
+  fetcher: ApiFetcher,
+  query: ReceivableAgingTableQuery
+): Promise<ReceivableAgingTableResponse> {
+  const get = fetcher.path(RECEIVABLE_AGING_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as ReceivableAgingTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type ReceivableAgingJsonQuery = OpQueryParams<Op>;
+export type ReceivableAgingJsonResponse = OpResponseBody<Op>;
+
+export async function fetchReceivableAgingJson(
+  fetcher: ApiFetcher,
+  query: ReceivableAgingJsonQuery
+): Promise<ReceivableAgingJsonResponse> {
+  const get = fetcher.path(RECEIVABLE_AGING_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as ReceivableAgingJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type ReceivableAgingCsvQuery = OpQueryParams<Op>;
+export type ReceivableAgingCsvResponse = Blob;
+
+export async function fetchReceivableAgingCsv(
+  fetcher: ApiFetcher,
+  query: ReceivableAgingCsvQuery
+): Promise<ReceivableAgingCsvResponse> {
+  const get = fetcher.path(RECEIVABLE_AGING_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as ReceivableAgingCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type ReceivableAgingXlsxQuery = OpQueryParams<Op>;
+export type ReceivableAgingXlsxResponse = Blob;
+
+export async function fetchReceivableAgingXlsx(
+  fetcher: ApiFetcher,
+  query: ReceivableAgingXlsxQuery
+): Promise<ReceivableAgingXlsxResponse> {
+  const get = fetcher.path(RECEIVABLE_AGING_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as ReceivableAgingXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type ReceivableAgingPdfQuery = OpQueryParams<Op>;
+export type ReceivableAgingPdfResponse = Blob;
+
+export async function fetchReceivableAgingPdf(
+  fetcher: ApiFetcher,
+  query: ReceivableAgingPdfQuery
+): Promise<ReceivableAgingPdfResponse> {
+  const get = fetcher.path(RECEIVABLE_AGING_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as ReceivableAgingPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/sales-by-items.ts b/shared/sdk-ts/src/reports/sales-by-items.ts
new file mode 100644
index 000000000..c374b337d
--- /dev/null
+++ b/shared/sdk-ts/src/reports/sales-by-items.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const SALES_BY_ITEMS_ROUTE = '/api/reports/sales-by-items' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof SALES_BY_ITEMS_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type SalesByItemsTableQuery = OpQueryParams<Op>;
+export type SalesByItemsTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchSalesByItemsTable(
+  fetcher: ApiFetcher,
+  query: SalesByItemsTableQuery
+): Promise<SalesByItemsTableResponse> {
+  const get = fetcher.path(SALES_BY_ITEMS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as SalesByItemsTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type SalesByItemsJsonQuery = OpQueryParams<Op>;
+export type SalesByItemsJsonResponse = OpResponseBody<Op>;
+
+export async function fetchSalesByItemsJson(
+  fetcher: ApiFetcher,
+  query: SalesByItemsJsonQuery
+): Promise<SalesByItemsJsonResponse> {
+  const get = fetcher.path(SALES_BY_ITEMS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as SalesByItemsJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type SalesByItemsCsvQuery = OpQueryParams<Op>;
+export type SalesByItemsCsvResponse = Blob;
+
+export async function fetchSalesByItemsCsv(
+  fetcher: ApiFetcher,
+  query: SalesByItemsCsvQuery
+): Promise<SalesByItemsCsvResponse> {
+  const get = fetcher.path(SALES_BY_ITEMS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as SalesByItemsCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type SalesByItemsXlsxQuery = OpQueryParams<Op>;
+export type SalesByItemsXlsxResponse = Blob;
+
+export async function fetchSalesByItemsXlsx(
+  fetcher: ApiFetcher,
+  query: SalesByItemsXlsxQuery
+): Promise<SalesByItemsXlsxResponse> {
+  const get = fetcher.path(SALES_BY_ITEMS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as SalesByItemsXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type SalesByItemsPdfQuery = OpQueryParams<Op>;
+export type SalesByItemsPdfResponse = Blob;
+
+export async function fetchSalesByItemsPdf(
+  fetcher: ApiFetcher,
+  query: SalesByItemsPdfQuery
+): Promise<SalesByItemsPdfResponse> {
+  const get = fetcher.path(SALES_BY_ITEMS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as SalesByItemsPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/sales-tax-liability.ts b/shared/sdk-ts/src/reports/sales-tax-liability.ts
new file mode 100644
index 000000000..1ca267fb8
--- /dev/null
+++ b/shared/sdk-ts/src/reports/sales-tax-liability.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const SALES_TAX_LIABILITY_ROUTE = '/api/reports/sales-tax-liability-summary' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof SALES_TAX_LIABILITY_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type SalesTaxLiabilityTableQuery = OpQueryParams<Op>;
+export type SalesTaxLiabilityTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchSalesTaxLiabilityTable(
+  fetcher: ApiFetcher,
+  query: SalesTaxLiabilityTableQuery
+): Promise<SalesTaxLiabilityTableResponse> {
+  const get = fetcher.path(SALES_TAX_LIABILITY_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as SalesTaxLiabilityTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type SalesTaxLiabilityJsonQuery = OpQueryParams<Op>;
+export type SalesTaxLiabilityJsonResponse = OpResponseBody<Op>;
+
+export async function fetchSalesTaxLiabilityJson(
+  fetcher: ApiFetcher,
+  query: SalesTaxLiabilityJsonQuery
+): Promise<SalesTaxLiabilityJsonResponse> {
+  const get = fetcher.path(SALES_TAX_LIABILITY_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as SalesTaxLiabilityJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type SalesTaxLiabilityCsvQuery = OpQueryParams<Op>;
+export type SalesTaxLiabilityCsvResponse = Blob;
+
+export async function fetchSalesTaxLiabilityCsv(
+  fetcher: ApiFetcher,
+  query: SalesTaxLiabilityCsvQuery
+): Promise<SalesTaxLiabilityCsvResponse> {
+  const get = fetcher.path(SALES_TAX_LIABILITY_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as SalesTaxLiabilityCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type SalesTaxLiabilityXlsxQuery = OpQueryParams<Op>;
+export type SalesTaxLiabilityXlsxResponse = Blob;
+
+export async function fetchSalesTaxLiabilityXlsx(
+  fetcher: ApiFetcher,
+  query: SalesTaxLiabilityXlsxQuery
+): Promise<SalesTaxLiabilityXlsxResponse> {
+  const get = fetcher.path(SALES_TAX_LIABILITY_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as SalesTaxLiabilityXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type SalesTaxLiabilityPdfQuery = OpQueryParams<Op>;
+export type SalesTaxLiabilityPdfResponse = Blob;
+
+export async function fetchSalesTaxLiabilityPdf(
+  fetcher: ApiFetcher,
+  query: SalesTaxLiabilityPdfQuery
+): Promise<SalesTaxLiabilityPdfResponse> {
+  const get = fetcher.path(SALES_TAX_LIABILITY_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as SalesTaxLiabilityPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/transactions-customers.ts b/shared/sdk-ts/src/reports/transactions-customers.ts
new file mode 100644
index 000000000..df34f73a8
--- /dev/null
+++ b/shared/sdk-ts/src/reports/transactions-customers.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const TRANSACTIONS_CUSTOMERS_ROUTE = '/api/reports/transactions-by-customers' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof TRANSACTIONS_CUSTOMERS_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type TransactionsByCustomersTableQuery = OpQueryParams<Op>;
+export type TransactionsByCustomersTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchTransactionsByCustomersTable(
+  fetcher: ApiFetcher,
+  query: TransactionsByCustomersTableQuery
+): Promise<TransactionsByCustomersTableResponse> {
+  const get = fetcher.path(TRANSACTIONS_CUSTOMERS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as TransactionsByCustomersTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type TransactionsByCustomersJsonQuery = OpQueryParams<Op>;
+export type TransactionsByCustomersJsonResponse = OpResponseBody<Op>;
+
+export async function fetchTransactionsByCustomersJson(
+  fetcher: ApiFetcher,
+  query: TransactionsByCustomersJsonQuery
+): Promise<TransactionsByCustomersJsonResponse> {
+  const get = fetcher.path(TRANSACTIONS_CUSTOMERS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as TransactionsByCustomersJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type TransactionsByCustomersCsvQuery = OpQueryParams<Op>;
+export type TransactionsByCustomersCsvResponse = Blob;
+
+export async function fetchTransactionsByCustomersCsv(
+  fetcher: ApiFetcher,
+  query: TransactionsByCustomersCsvQuery
+): Promise<TransactionsByCustomersCsvResponse> {
+  const get = fetcher.path(TRANSACTIONS_CUSTOMERS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as TransactionsByCustomersCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type TransactionsByCustomersXlsxQuery = OpQueryParams<Op>;
+export type TransactionsByCustomersXlsxResponse = Blob;
+
+export async function fetchTransactionsByCustomersXlsx(
+  fetcher: ApiFetcher,
+  query: TransactionsByCustomersXlsxQuery
+): Promise<TransactionsByCustomersXlsxResponse> {
+  const get = fetcher.path(TRANSACTIONS_CUSTOMERS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as TransactionsByCustomersXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type TransactionsByCustomersPdfQuery = OpQueryParams<Op>;
+export type TransactionsByCustomersPdfResponse = Blob;
+
+export async function fetchTransactionsByCustomersPdf(
+  fetcher: ApiFetcher,
+  query: TransactionsByCustomersPdfQuery
+): Promise<TransactionsByCustomersPdfResponse> {
+  const get = fetcher.path(TRANSACTIONS_CUSTOMERS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as TransactionsByCustomersPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/transactions-reference.ts b/shared/sdk-ts/src/reports/transactions-reference.ts
new file mode 100644
index 000000000..b83f740cd
--- /dev/null
+++ b/shared/sdk-ts/src/reports/transactions-reference.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const TRANSACTIONS_REFERENCE_ROUTE = '/api/reports/transactions-by-reference' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof TRANSACTIONS_REFERENCE_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type TransactionsByReferenceTableQuery = OpQueryParams<Op>;
+export type TransactionsByReferenceTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchTransactionsByReferenceTable(
+  fetcher: ApiFetcher,
+  query: TransactionsByReferenceTableQuery
+): Promise<TransactionsByReferenceTableResponse> {
+  const get = fetcher.path(TRANSACTIONS_REFERENCE_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as TransactionsByReferenceTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type TransactionsByReferenceJsonQuery = OpQueryParams<Op>;
+export type TransactionsByReferenceJsonResponse = OpResponseBody<Op>;
+
+export async function fetchTransactionsByReferenceJson(
+  fetcher: ApiFetcher,
+  query: TransactionsByReferenceJsonQuery
+): Promise<TransactionsByReferenceJsonResponse> {
+  const get = fetcher.path(TRANSACTIONS_REFERENCE_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as TransactionsByReferenceJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type TransactionsByReferenceCsvQuery = OpQueryParams<Op>;
+export type TransactionsByReferenceCsvResponse = Blob;
+
+export async function fetchTransactionsByReferenceCsv(
+  fetcher: ApiFetcher,
+  query: TransactionsByReferenceCsvQuery
+): Promise<TransactionsByReferenceCsvResponse> {
+  const get = fetcher.path(TRANSACTIONS_REFERENCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as TransactionsByReferenceCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type TransactionsByReferenceXlsxQuery = OpQueryParams<Op>;
+export type TransactionsByReferenceXlsxResponse = Blob;
+
+export async function fetchTransactionsByReferenceXlsx(
+  fetcher: ApiFetcher,
+  query: TransactionsByReferenceXlsxQuery
+): Promise<TransactionsByReferenceXlsxResponse> {
+  const get = fetcher.path(TRANSACTIONS_REFERENCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as TransactionsByReferenceXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type TransactionsByReferencePdfQuery = OpQueryParams<Op>;
+export type TransactionsByReferencePdfResponse = Blob;
+
+export async function fetchTransactionsByReferencePdf(
+  fetcher: ApiFetcher,
+  query: TransactionsByReferencePdfQuery
+): Promise<TransactionsByReferencePdfResponse> {
+  const get = fetcher.path(TRANSACTIONS_REFERENCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as TransactionsByReferencePdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/transactions-vendors.ts b/shared/sdk-ts/src/reports/transactions-vendors.ts
new file mode 100644
index 000000000..b7804941d
--- /dev/null
+++ b/shared/sdk-ts/src/reports/transactions-vendors.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const TRANSACTIONS_VENDORS_ROUTE = '/api/reports/transactions-by-vendors' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof TRANSACTIONS_VENDORS_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type TransactionsByVendorsTableQuery = OpQueryParams<Op>;
+export type TransactionsByVendorsTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchTransactionsByVendorsTable(
+  fetcher: ApiFetcher,
+  query: TransactionsByVendorsTableQuery
+): Promise<TransactionsByVendorsTableResponse> {
+  const get = fetcher.path(TRANSACTIONS_VENDORS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as TransactionsByVendorsTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type TransactionsByVendorsJsonQuery = OpQueryParams<Op>;
+export type TransactionsByVendorsJsonResponse = OpResponseBody<Op>;
+
+export async function fetchTransactionsByVendorsJson(
+  fetcher: ApiFetcher,
+  query: TransactionsByVendorsJsonQuery
+): Promise<TransactionsByVendorsJsonResponse> {
+  const get = fetcher.path(TRANSACTIONS_VENDORS_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as TransactionsByVendorsJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type TransactionsByVendorsCsvQuery = OpQueryParams<Op>;
+export type TransactionsByVendorsCsvResponse = Blob;
+
+export async function fetchTransactionsByVendorsCsv(
+  fetcher: ApiFetcher,
+  query: TransactionsByVendorsCsvQuery
+): Promise<TransactionsByVendorsCsvResponse> {
+  const get = fetcher.path(TRANSACTIONS_VENDORS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as TransactionsByVendorsCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type TransactionsByVendorsXlsxQuery = OpQueryParams<Op>;
+export type TransactionsByVendorsXlsxResponse = Blob;
+
+export async function fetchTransactionsByVendorsXlsx(
+  fetcher: ApiFetcher,
+  query: TransactionsByVendorsXlsxQuery
+): Promise<TransactionsByVendorsXlsxResponse> {
+  const get = fetcher.path(TRANSACTIONS_VENDORS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as TransactionsByVendorsXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type TransactionsByVendorsPdfQuery = OpQueryParams<Op>;
+export type TransactionsByVendorsPdfResponse = Blob;
+
+export async function fetchTransactionsByVendorsPdf(
+  fetcher: ApiFetcher,
+  query: TransactionsByVendorsPdfQuery
+): Promise<TransactionsByVendorsPdfResponse> {
+  const get = fetcher.path(TRANSACTIONS_VENDORS_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as TransactionsByVendorsPdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/trial-balance.ts b/shared/sdk-ts/src/reports/trial-balance.ts
new file mode 100644
index 000000000..a5f58e03b
--- /dev/null
+++ b/shared/sdk-ts/src/reports/trial-balance.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const TRIAL_BALANCE_ROUTE = '/api/reports/trial-balance-sheet' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof TRIAL_BALANCE_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type TrialBalanceTableQuery = OpQueryParams<Op>;
+export type TrialBalanceTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchTrialBalanceTable(
+  fetcher: ApiFetcher,
+  query: TrialBalanceTableQuery
+): Promise<TrialBalanceTableResponse> {
+  const get = fetcher.path(TRIAL_BALANCE_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as TrialBalanceTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type TrialBalanceJsonQuery = OpQueryParams<Op>;
+export type TrialBalanceJsonResponse = OpResponseBody<Op>;
+
+export async function fetchTrialBalanceJson(
+  fetcher: ApiFetcher,
+  query: TrialBalanceJsonQuery
+): Promise<TrialBalanceJsonResponse> {
+  const get = fetcher.path(TRIAL_BALANCE_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as TrialBalanceJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type TrialBalanceCsvQuery = OpQueryParams<Op>;
+export type TrialBalanceCsvResponse = Blob;
+
+export async function fetchTrialBalanceCsv(
+  fetcher: ApiFetcher,
+  query: TrialBalanceCsvQuery
+): Promise<TrialBalanceCsvResponse> {
+  const get = fetcher.path(TRIAL_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as TrialBalanceCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type TrialBalanceXlsxQuery = OpQueryParams<Op>;
+export type TrialBalanceXlsxResponse = Blob;
+
+export async function fetchTrialBalanceXlsx(
+  fetcher: ApiFetcher,
+  query: TrialBalanceXlsxQuery
+): Promise<TrialBalanceXlsxResponse> {
+  const get = fetcher.path(TRIAL_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as TrialBalanceXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type TrialBalancePdfQuery = OpQueryParams<Op>;
+export type TrialBalancePdfResponse = Blob;
+
+export async function fetchTrialBalancePdf(
+  fetcher: ApiFetcher,
+  query: TrialBalancePdfQuery
+): Promise<TrialBalancePdfResponse> {
+  const get = fetcher.path(TRIAL_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as TrialBalancePdfResponse;
+}
diff --git a/shared/sdk-ts/src/reports/vendor-balance.ts b/shared/sdk-ts/src/reports/vendor-balance.ts
new file mode 100644
index 000000000..c4bc3095b
--- /dev/null
+++ b/shared/sdk-ts/src/reports/vendor-balance.ts
@@ -0,0 +1,80 @@
+import type { OpArgType } from 'openapi-typescript-fetch';
+import type { ApiFetcher } from '../fetch-utils';
+import type { paths } from '../schema';
+import {
+  OpForPath,
+  OpQueryParams,
+  OpResponseBody,
+  OpResponseBodyTable,
+} from '../utils';
+
+export const VENDOR_BALANCE_ROUTE = '/api/reports/vendor-balance-summary' as const satisfies keyof paths;
+
+type Op = OpForPath<typeof VENDOR_BALANCE_ROUTE, 'get'>;
+type Arg = OpArgType<Op>;
+
+// Table format (existing functionality)
+export type VendorBalanceTableQuery = OpQueryParams<Op>;
+export type VendorBalanceTableResponse = OpResponseBodyTable<Op>;
+
+export async function fetchVendorBalanceTable(
+  fetcher: ApiFetcher,
+  query: VendorBalanceTableQuery
+): Promise<VendorBalanceTableResponse> {
+  const get = fetcher.path(VENDOR_BALANCE_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as VendorBalanceTableResponse;
+}
+
+// JSON format - Note: may only have table format in schema
+// Using type assertion for JSON format compatibility
+export type VendorBalanceJsonQuery = OpQueryParams<Op>;
+export type VendorBalanceJsonResponse = OpResponseBody<Op>;
+
+export async function fetchVendorBalanceJson(
+  fetcher: ApiFetcher,
+  query: VendorBalanceJsonQuery
+): Promise<VendorBalanceJsonResponse> {
+  const get = fetcher.path(VENDOR_BALANCE_ROUTE).method('get').create();
+  const { data } = await get(query as Arg);
+  return data as unknown as VendorBalanceJsonResponse;
+}
+
+// CSV format (returns Blob)
+export type VendorBalanceCsvQuery = OpQueryParams<Op>;
+export type VendorBalanceCsvResponse = Blob;
+
+export async function fetchVendorBalanceCsv(
+  fetcher: ApiFetcher,
+  query: VendorBalanceCsvQuery
+): Promise<VendorBalanceCsvResponse> {
+  const get = fetcher.path(VENDOR_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/csv' } as Arg);
+  return response.data as unknown as VendorBalanceCsvResponse;
+}
+
+// XLSX format (returns Blob)
+export type VendorBalanceXlsxQuery = OpQueryParams<Op>;
+export type VendorBalanceXlsxResponse = Blob;
+
+export async function fetchVendorBalanceXlsx(
+  fetcher: ApiFetcher,
+  query: VendorBalanceXlsxQuery
+): Promise<VendorBalanceXlsxResponse> {
+  const get = fetcher.path(VENDOR_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/xlsx' } as Arg);
+  return response.data as unknown as VendorBalanceXlsxResponse;
+}
+
+// PDF format (returns Blob)
+export type VendorBalancePdfQuery = OpQueryParams<Op>;
+export type VendorBalancePdfResponse = Blob;
+
+export async function fetchVendorBalancePdf(
+  fetcher: ApiFetcher,
+  query: VendorBalancePdfQuery
+): Promise<VendorBalancePdfResponse> {
+  const get = fetcher.path(VENDOR_BALANCE_ROUTE).method('get').create();
+  const response = await get({ ...query, Accept: 'application/pdf' } as Arg);
+  return response.data as unknown as VendorBalancePdfResponse;
+}
diff --git a/shared/sdk-ts/src/utils/index.ts b/shared/sdk-ts/src/utils/index.ts
index aa89f3c25..52784044d 100644
--- a/shared/sdk-ts/src/utils/index.ts
+++ b/shared/sdk-ts/src/utils/index.ts
@@ -35,3 +35,24 @@ export type OpResponseBodyTable<O> = O extends {
 }
   ? R
   : unknown;
+
+/** Response body for CSV format (returns as Blob) */
+export type OpResponseBodyCsv<O> = O extends {
+  responses: { 200: { content: { 'application/csv': infer R } } };
+}
+  ? R
+  : Blob;
+
+/** Response body for XLSX format (returns as Blob) */
+export type OpResponseBodyXlsx<O> = O extends {
+  responses: { 200: { content: { 'application/xlsx': infer R } } };
+}
+  ? R
+  : Blob;
+
+/** Response body for PDF format (returns as Blob) */
+export type OpResponseBodyPdf<O> = O extends {
+  responses: { 200: { content: { 'application/pdf': infer R } } };
+}
+  ? R
+  : Blob;