@classytic/commerce-sdk 0.1.1 → 0.2.1

package/dist/accounting/api/constants.js

@@ -0,0 +1,79 @@
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/accounting/api/constants.ts
+/**
+* Accounting Constants APIs — Static lookups (no DB, read-only)
+*
+* Account Types (BFRS), Journal Types, Tax Codes (BD VAT/TDS/VDS).
+*
+* Each lookup uses a tiny `BaseApi`-derived class as a prefix carrier so the
+* `/api/v1` versioning lives in arc-next's BaseApi (single source of truth)
+* and we never hardcode it. The class doesn't enable CRUD — only the
+* `this.request()` escape hatch on a custom sub-path.
+*/
+var AccountTypeApi = class extends BaseApi {
+	constructor() {
+		super("accounting/account-types");
+	}
+	list(params) {
+		return this.request("GET", this.baseUrl, { params });
+	}
+	byCode(code) {
+		return this.request("GET", `${this.baseUrl}/${code}`);
+	}
+};
+var JournalTypeApi = class extends BaseApi {
+	constructor() {
+		super("accounting/journal-types");
+	}
+	list() {
+		return this.request("GET", this.baseUrl);
+	}
+	byCode(code) {
+		return this.request("GET", `${this.baseUrl}/${code}`);
+	}
+};
+var TaxCodeApi = class extends BaseApi {
+	constructor() {
+		super("accounting/tax-codes");
+	}
+	list() {
+		return this.request("GET", this.baseUrl);
+	}
+	divisions() {
+		return this.request("GET", `${this.baseUrl}/divisions`);
+	}
+};
+const accountTypeApi = new AccountTypeApi();
+const journalTypeApi = new JournalTypeApi();
+const taxCodeApi = new TaxCodeApi();
+/** GET /accounting/account-types */
+async function getAccountTypes(opts = {}) {
+	return accountTypeApi.list({
+		search: opts.search,
+		category: opts.category
+	});
+}
+/** GET /accounting/account-types/:code */
+async function getAccountType({ code }) {
+	return accountTypeApi.byCode(code);
+}
+/** GET /accounting/journal-types */
+async function getJournalTypes(_opts = {}) {
+	return journalTypeApi.list();
+}
+/** GET /accounting/journal-types/:code */
+async function getJournalType({ code }) {
+	return journalTypeApi.byCode(code);
+}
+/** GET /accounting/tax-codes */
+async function getTaxCodes(_opts = {}) {
+	return taxCodeApi.list();
+}
+/** GET /accounting/tax-codes/divisions */
+async function getTaxDivisions(_opts = {}) {
+	return taxCodeApi.divisions();
+}
+
+//#endregion
+export { getAccountType, getAccountTypes, getJournalType, getJournalTypes, getTaxCodes, getTaxDivisions };

package/dist/accounting/api/fiscal-period.d.ts

@@ -0,0 +1,31 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+import { CreateFiscalPeriodPayload, FiscalPeriod, UpdateFiscalPeriodPayload } from "../types/index.js";
+
+//#region src/accounting/api/fiscal-period.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+declare class FiscalPeriodApi extends BaseApi<FiscalPeriod, CreateFiscalPeriodPayload, UpdateFiscalPeriodPayload> {
+  constructor(config?: {});
+  /** Close a fiscal period (prevents posting). */
+  close({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<FiscalPeriod>>;
+  /** Reopen a closed fiscal period. */
+  reopen({
+    token,
+    id,
+    options
+  }: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<FiscalPeriod>>;
+}
+declare const fiscalPeriodApi: FiscalPeriodApi;
+//#endregion
+export { FiscalPeriodApi, fiscalPeriodApi };

package/dist/accounting/api/fiscal-period.js

@@ -0,0 +1,30 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/accounting/api/fiscal-period.ts
+/**
+* Fiscal Period API — CRUD + Close/Reopen
+*/
+var FiscalPeriodApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("accounting/fiscal-periods", config);
+	}
+	/** Close a fiscal period (prevents posting). */
+	async close({ token, id, options = {} }) {
+		return handleApiRequest("PATCH", `${this.baseUrl}/${id}/close`, {
+			token,
+			...options
+		});
+	}
+	/** Reopen a closed fiscal period. */
+	async reopen({ token, id, options = {} }) {
+		return handleApiRequest("PATCH", `${this.baseUrl}/${id}/reopen`, {
+			token,
+			...options
+		});
+	}
+};
+const fiscalPeriodApi = new FiscalPeriodApi();
+
+//#endregion
+export { FiscalPeriodApi, fiscalPeriodApi };

package/dist/accounting/api/index.d.ts

@@ -0,0 +1,7 @@
+import { AccountApi, accountApi } from "./account.js";
+import { JournalEntryApi, journalEntryApi } from "./journal-entry.js";
+import { FiscalPeriodApi, fiscalPeriodApi } from "./fiscal-period.js";
+import { BudgetApi, budgetApi } from "./budget.js";
+import { getAccountType, getAccountTypes, getJournalType, getJournalTypes, getTaxCodes, getTaxDivisions } from "./constants.js";
+import { getBalanceSheet, getBudgetVsActual, getCashFlow, getGeneralLedger, getIncomeStatement, getTrialBalance } from "./reports.js";
+import { backfillPostings, closeDay, getDayCloseOversight, getPostingStatus, reopenDay } from "./posting.js";

package/dist/accounting/api/journal-entry.d.ts

@@ -0,0 +1,66 @@
+import { ApiResponse, BaseApi, RequestOptions } from "../../core/api-factory.js";
+import { CreateJournalEntryPayload, JournalEntry, UpdateJournalEntryPayload } from "../types/index.js";
+
+//#region src/accounting/api/journal-entry.d.ts
+type FetchOptions = Omit<RequestOptions, "token" | "organizationId">;
+type JournalEntryAction = "post" | "reverse" | "duplicate" | "archive";
+interface JournalEntryActionPayload {
+  /** For action="reverse" — date for the counter-entry. Defaults to today. */
+  reversalDate?: string;
+}
+declare class JournalEntryApi extends BaseApi<JournalEntry, CreateJournalEntryPayload, UpdateJournalEntryPayload> {
+  constructor(config?: {});
+  /**
+   * Unified action endpoint — POST /journal-entries/:id/action
+   * body: { action, ...actionData }
+   */
+  runAction({
+    token,
+    id,
+    action,
+    payload,
+    options
+  }: {
+    token: string;
+    id: string;
+    action: JournalEntryAction;
+    payload?: JournalEntryActionPayload;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<JournalEntry>>;
+  /** draft → posted */
+  post(args: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<JournalEntry>>;
+  /**
+   * posted → posted (creates counter-entry on `reversalDate`).
+   * Forward correction: original stays posted with `reversed=true`.
+   */
+  reverse({
+    token,
+    id,
+    reversalDate,
+    options
+  }: {
+    token: string;
+    id: string;
+    reversalDate?: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<JournalEntry>>;
+  /** any → new draft (clones items, today's date, fresh state) */
+  duplicate(args: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<JournalEntry>>;
+  /** draft → archived. Posted entries cannot be archived — use reverse. */
+  archive(args: {
+    token: string;
+    id: string;
+    options?: FetchOptions;
+  }): Promise<ApiResponse<JournalEntry>>;
+}
+declare const journalEntryApi: JournalEntryApi;
+//#endregion
+export { JournalEntryApi, journalEntryApi };

package/dist/accounting/api/journal-entry.js

@@ -0,0 +1,72 @@
+import { handleApiRequest } from "../../core/api-handler.js";
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/accounting/api/journal-entry.ts
+/**
+* Journal Entry API — CRUD + unified action endpoint
+*
+* State transitions go through POST /:id/action (createActionRouter).
+* Legacy PATCH /:id/post, /:id/reverse, /:id/unpost, POST /:id/duplicate
+* routes were removed in be-prod alongside the introduction of period-locks.
+*
+* `unpost` is intentionally gone — Odoo-correct: posted is final, use reverse
+* (which creates a counter-entry on `reversalDate` and leaves the original
+* posted-but-marked-`reversed`).
+*/
+var JournalEntryApi = class extends BaseApi {
+	constructor(config = {}) {
+		super("accounting/journal-entries", config);
+	}
+	/**
+	* Unified action endpoint — POST /journal-entries/:id/action
+	* body: { action, ...actionData }
+	*/
+	async runAction({ token, id, action, payload, options = {} }) {
+		return handleApiRequest("POST", `${this.baseUrl}/${id}/action`, {
+			token,
+			body: {
+				action,
+				...payload ?? {}
+			},
+			...options
+		});
+	}
+	/** draft → posted */
+	post(args) {
+		return this.runAction({
+			...args,
+			action: "post"
+		});
+	}
+	/**
+	* posted → posted (creates counter-entry on `reversalDate`).
+	* Forward correction: original stays posted with `reversed=true`.
+	*/
+	reverse({ token, id, reversalDate, options = {} }) {
+		return this.runAction({
+			token,
+			id,
+			action: "reverse",
+			payload: reversalDate ? { reversalDate } : void 0,
+			options
+		});
+	}
+	/** any → new draft (clones items, today's date, fresh state) */
+	duplicate(args) {
+		return this.runAction({
+			...args,
+			action: "duplicate"
+		});
+	}
+	/** draft → archived. Posted entries cannot be archived — use reverse. */
+	archive(args) {
+		return this.runAction({
+			...args,
+			action: "archive"
+		});
+	}
+};
+const journalEntryApi = new JournalEntryApi();
+
+//#endregion
+export { JournalEntryApi, journalEntryApi };

package/dist/accounting/api/posting.d.ts

@@ -0,0 +1,55 @@
+import { BackfillResult, DayCloseOversight, DayCloseResult, PostingStatus } from "../types/index.js";
+
+//#region src/accounting/api/posting.d.ts
+declare function closeDay({
+  date
+}: {
+  token?: string;
+  date?: string;
+}): Promise<{
+  success: boolean;
+  data: DayCloseResult;
+}>;
+declare function reopenDay({
+  date,
+  reason
+}: {
+  token?: string;
+  date: string;
+  reason: string;
+}): Promise<{
+  success: boolean;
+  data: {
+    reopened: boolean;
+    date: string;
+    originalEntryId: string;
+    reversalEntryId: string | null;
+    reversalDate: string;
+    message: string;
+  };
+}>;
+declare function backfillPostings({
+  startDate,
+  endDate
+}: {
+  token?: string;
+  startDate: string;
+  endDate: string;
+}): Promise<{
+  success: boolean;
+  data: BackfillResult;
+}>;
+declare function getPostingStatus(_opts?: {
+  token?: string;
+}): Promise<{
+  success: boolean;
+  data: PostingStatus;
+}>;
+declare function getDayCloseOversight(_opts?: {
+  token?: string;
+}): Promise<{
+  success: boolean;
+  data: DayCloseOversight;
+}>;
+//#endregion
+export { backfillPostings, closeDay, getDayCloseOversight, getPostingStatus, reopenDay };

package/dist/accounting/api/posting.js

@@ -0,0 +1,70 @@
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/accounting/api/posting.ts
+/**
+* Posting API — Day Close, Reopen, Backfill, Status, Oversight
+*
+* Day-close lifecycle is a unified action endpoint:
+*   POST /accounting/posting/day/_/action  body: { action, ... }
+*
+* Uses a `BaseApi`-derived `PostingApi` class as a prefix carrier so the
+* `/api/v1` versioning lives in arc-next's BaseApi (single source of truth).
+*/
+var PostingApi = class extends BaseApi {
+	constructor() {
+		super("accounting/posting");
+	}
+	/** POST /accounting/posting/day/_/action — Stripe-style action endpoint */
+	dayAction(action, extra = {}) {
+		return this.request("POST", `${this.baseUrl}/day/_/action`, { data: {
+			action,
+			...extra
+		} });
+	}
+	closeDay(date) {
+		return this.dayAction("close", date ? { date } : {});
+	}
+	reopenDay(date, reason) {
+		return this.dayAction("reopen", {
+			date,
+			reason
+		});
+	}
+	backfill(startDate, endDate) {
+		return this.dayAction("backfill", {
+			startDate,
+			endDate
+		});
+	}
+	/** GET /accounting/posting/status — single-branch (current scope) */
+	status() {
+		return this.request("GET", `${this.baseUrl}/status`);
+	}
+	/**
+	* GET /accounting/posting/oversight — cross-branch days-behind summary.
+	* Not branch-scoped — returns every branch the caller can see.
+	* Permission: admin / finance_admin.
+	*/
+	oversight() {
+		return this.request("GET", `${this.baseUrl}/oversight`);
+	}
+};
+const postingApi = new PostingApi();
+async function closeDay({ date }) {
+	return postingApi.closeDay(date);
+}
+async function reopenDay({ date, reason }) {
+	return postingApi.reopenDay(date, reason);
+}
+async function backfillPostings({ startDate, endDate }) {
+	return postingApi.backfill(startDate, endDate);
+}
+async function getPostingStatus(_opts = {}) {
+	return postingApi.status();
+}
+async function getDayCloseOversight(_opts = {}) {
+	return postingApi.oversight();
+}
+
+//#endregion
+export { backfillPostings, closeDay, getDayCloseOversight, getPostingStatus, reopenDay };

package/dist/accounting/api/reports.d.ts

@@ -0,0 +1,63 @@
+import { BalanceSheetReport, BudgetVsActualReport, CashFlowReport, GeneralLedgerReport, IncomeStatementReport, ReportDateParams, TrialBalanceReport } from "../types/index.js";
+
+//#region src/accounting/api/reports.d.ts
+declare function getTrialBalance({
+  params,
+  accountId
+}: {
+  token?: string;
+  params: ReportDateParams;
+  accountId?: string;
+}): Promise<{
+  success: boolean;
+  data: TrialBalanceReport;
+}>;
+declare function getBalanceSheet({
+  params
+}: {
+  token?: string;
+  params: ReportDateParams;
+}): Promise<{
+  success: boolean;
+  data: BalanceSheetReport;
+}>;
+declare function getIncomeStatement({
+  params
+}: {
+  token?: string;
+  params: ReportDateParams;
+}): Promise<{
+  success: boolean;
+  data: IncomeStatementReport;
+}>;
+declare function getGeneralLedger({
+  params,
+  accountId
+}: {
+  token?: string;
+  params: ReportDateParams;
+  accountId?: string;
+}): Promise<{
+  success: boolean;
+  data: GeneralLedgerReport;
+}>;
+declare function getCashFlow({
+  params
+}: {
+  token?: string;
+  params: ReportDateParams;
+}): Promise<{
+  success: boolean;
+  data: CashFlowReport;
+}>;
+declare function getBudgetVsActual({
+  params
+}: {
+  token?: string;
+  params: ReportDateParams;
+}): Promise<{
+  success: boolean;
+  data: BudgetVsActualReport;
+}>;
+//#endregion
+export { getBalanceSheet, getBudgetVsActual, getCashFlow, getGeneralLedger, getIncomeStatement, getTrialBalance };

package/dist/accounting/api/reports.js

@@ -0,0 +1,81 @@
+import { BaseApi } from "../../core/api-factory.js";
+
+//#region src/accounting/api/reports.ts
+/**
+* Accounting Reports API — Financial statements powered by @classytic/ledger
+*
+* Uses a `BaseApi`-derived `ReportsApi` class so the `/api/v1` prefix lives in
+* arc-next's BaseApi (single source of truth) — no hardcoded prefix here.
+*/
+function buildReportParams(params) {
+	const out = { dateOption: params.dateOption };
+	switch (params.dateOption) {
+		case "month":
+			if (params.month) out.month = params.month;
+			if (params.year) out.year = params.year;
+			break;
+		case "quarter":
+			if (params.quarter) out.quarter = params.quarter;
+			if (params.year) out.year = params.year;
+			break;
+		case "year":
+			if (params.year) out.year = params.year;
+			break;
+		case "custom":
+			if (params.startDate) out.startDate = params.startDate;
+			if (params.endDate) out.endDate = params.endDate;
+			break;
+	}
+	return out;
+}
+var ReportsApi = class extends BaseApi {
+	constructor() {
+		super("accounting/reports");
+	}
+	trialBalance(params, accountId) {
+		return this.request("GET", `${this.baseUrl}/trial-balance`, { params: {
+			...buildReportParams(params),
+			...accountId ? { accountId } : {}
+		} });
+	}
+	balanceSheet(params) {
+		return this.request("GET", `${this.baseUrl}/balance-sheet`, { params: buildReportParams(params) });
+	}
+	incomeStatement(params) {
+		return this.request("GET", `${this.baseUrl}/income-statement`, { params: buildReportParams(params) });
+	}
+	generalLedger(params, accountId) {
+		return this.request("GET", `${this.baseUrl}/general-ledger`, { params: {
+			...buildReportParams(params),
+			...accountId ? { accountId } : {}
+		} });
+	}
+	cashFlow(params) {
+		return this.request("GET", `${this.baseUrl}/cash-flow`, { params: buildReportParams(params) });
+	}
+	budgetVsActual(params) {
+		return this.request("GET", `${this.baseUrl}/budget-vs-actual`, { params: buildReportParams(params) });
+	}
+};
+const reportsApi = new ReportsApi();
+async function getTrialBalance({ params, accountId }) {
+	return reportsApi.trialBalance(params, accountId);
+}
+async function getBalanceSheet({ params }) {
+	return reportsApi.balanceSheet(params);
+}
+async function getIncomeStatement({ params }) {
+	return reportsApi.incomeStatement(params);
+}
+async function getGeneralLedger({ params, accountId }) {
+	return reportsApi.generalLedger(params, accountId);
+}
+async function getCashFlow({ params }) {
+	return reportsApi.cashFlow(params);
+}
+async function getBudgetVsActual({ params }) {
+	return reportsApi.budgetVsActual(params);
+}
+
+//#endregion
+export { getBalanceSheet, getBudgetVsActual, getCashFlow, getGeneralLedger, getIncomeStatement, getTrialBalance };

package/dist/accounting/hooks/account.d.ts

@@ -0,0 +1,29 @@
+import { Account, AccountType, BulkCreateResult, CreateAccountPayload, SeedAccountsResult, UpdateAccountPayload } from "../types/index.js";
+import * as _tanstack_react_query0 from "@tanstack/react-query";
+import * as _classytic_arc_next_api0 from "@classytic/arc-next/api";
+import * as _classytic_arc_next_query0 from "@classytic/arc-next/query";
+import * as _classytic_arc_next0 from "@classytic/arc-next";
+
+//#region src/accounting/hooks/account.d.ts
+declare const accountHooks: _classytic_arc_next0.CrudHooksReturn<Account, CreateAccountPayload, UpdateAccountPayload>;
+declare const ACCOUNT_KEYS: _classytic_arc_next_query0.QueryKeys, useAccounts: {
+    (params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Account> | undefined): _classytic_arc_next_query0.ListQueryResult<Account>;
+    (token: string | null, params?: Record<string, unknown>, options?: _classytic_arc_next_query0.ListQueryOptions<Account> | undefined): _classytic_arc_next_query0.ListQueryResult<Account>;
+  }, useAccountDetail: {
+    (id: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Account> | undefined): _classytic_arc_next_query0.DetailQueryResult<Account>;
+    (id: string | null, token: string | null, options?: _classytic_arc_next_query0.DetailQueryOptions<Account> | undefined): _classytic_arc_next_query0.DetailQueryResult<Account>;
+  }, useAccountActions: () => _classytic_arc_next0.CrudActions<Account, CreateAccountPayload, UpdateAccountPayload>;
+declare const ACCOUNT_TYPE_KEYS: {
+  all: readonly ["account-types"];
+};
+declare function useAccountTypes(): {
+  accountTypes: AccountType[];
+  isLoading: boolean;
+  error: Error | null;
+};
+declare function useAccountSeed(): _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<SeedAccountsResult>, Error, void, unknown>;
+declare function useAccountEnable(): _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<Account>, Error, string, unknown>;
+declare function useAccountDisable(): _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<Account>, Error, string, unknown>;
+declare function useAccountBulkCreate(): _tanstack_react_query0.UseMutationResult<_classytic_arc_next_api0.ApiResponse<BulkCreateResult>, Error, CreateAccountPayload[], unknown>;
+//#endregion
+export { ACCOUNT_KEYS, ACCOUNT_TYPE_KEYS, accountHooks, useAccountActions, useAccountBulkCreate, useAccountDetail, useAccountDisable, useAccountEnable, useAccountSeed, useAccountTypes, useAccounts };

package/dist/accounting/hooks/account.js

@@ -0,0 +1,102 @@
+"use client";
+
+import { getToastHandler } from "../../core/react/mutation.factory.js";
+import { createCrudHooks } from "../../core/react/crud.factory.js";
+import { accountApi } from "../api/account.js";
+import { getAccountTypes } from "../api/constants.js";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+
+//#region src/accounting/hooks/account.ts
+/**
+* Account Hooks — Chart of Accounts CRUD + custom mutations
+*/
+const accountHooks = createCrudHooks({
+	api: accountApi,
+	entityKey: "accounts",
+	singular: "Account",
+	plural: "Accounts",
+	defaults: {
+		staleTime: Infinity,
+		gcTime: 1440 * 60 * 1e3
+	}
+});
+const { KEYS: ACCOUNT_KEYS, useList: useAccounts, useDetail: useAccountDetail, useActions: useAccountActions } = accountHooks;
+const ACCOUNT_TYPE_KEYS = { all: ["account-types"] };
+function useAccountTypes() {
+	const { data, isLoading, error } = useQuery({
+		queryKey: ACCOUNT_TYPE_KEYS.all,
+		queryFn: () => getAccountTypes({ token: "" }),
+		select: (res) => res.data ?? [],
+		staleTime: Infinity,
+		gcTime: 1440 * 60 * 1e3
+	});
+	return {
+		accountTypes: data ?? [],
+		isLoading,
+		error
+	};
+}
+function useAccountSeed() {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: () => accountApi.seed({ token: "" }),
+		onSuccess: () => {
+			getToastHandler()?.success?.("Chart of accounts seeded");
+			qc.invalidateQueries({ queryKey: ACCOUNT_KEYS.all });
+		},
+		onError: (err) => {
+			getToastHandler()?.error?.(err.message || "Failed to seed accounts");
+		}
+	});
+}
+function useAccountEnable() {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: (id) => accountApi.enable({
+			token: "",
+			id
+		}),
+		onSuccess: () => {
+			getToastHandler()?.success?.("Account enabled");
+			qc.invalidateQueries({ queryKey: ACCOUNT_KEYS.all });
+		},
+		onError: (err) => {
+			getToastHandler()?.error?.(err.message || "Failed to enable account");
+		}
+	});
+}
+function useAccountDisable() {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: (id) => accountApi.disable({
+			token: "",
+			id
+		}),
+		onSuccess: () => {
+			getToastHandler()?.success?.("Account disabled");
+			qc.invalidateQueries({ queryKey: ACCOUNT_KEYS.all });
+		},
+		onError: (err) => {
+			getToastHandler()?.error?.(err.message || "Failed to disable account");
+		}
+	});
+}
+function useAccountBulkCreate() {
+	const qc = useQueryClient();
+	return useMutation({
+		mutationFn: (accounts) => accountApi.bulkCreate({
+			token: "",
+			accounts
+		}),
+		onSuccess: () => {
+			getToastHandler()?.success?.("Accounts created");
+			qc.invalidateQueries({ queryKey: ACCOUNT_KEYS.all });
+		},
+		onError: (err) => {
+			getToastHandler()?.error?.(err.message || "Failed to bulk create accounts");
+		}
+	});
+}
+
+//#endregion
+export { ACCOUNT_KEYS, ACCOUNT_TYPE_KEYS, accountHooks, useAccountActions, useAccountBulkCreate, useAccountDetail, useAccountDisable, useAccountEnable, useAccountSeed, useAccountTypes, useAccounts };