@ngbplatform/ui 1.3.0

package/src/ngb/accounting/api.ts

@@ -0,0 +1,79 @@
+import { httpGet, httpPost, httpPut } from '../api/http';
+import type { ByIdsRequestDto, LookupItemDto } from '../api/contracts';
+import type {
+  ChartOfAccountsAccountDto,
+  ChartOfAccountsMetadataDto,
+  ChartOfAccountsPageDto,
+  ChartOfAccountsUpsertRequestDto,
+} from './types';
+
+export type GetChartOfAccountsPageArgs = {
+  offset?: number;
+  limit?: number;
+  search?: string | null;
+  onlyActive?: boolean | null;
+  includeDeleted?: boolean;
+  onlyDeleted?: boolean | null;
+};
+
+export async function getChartOfAccountsPage(
+  args: GetChartOfAccountsPageArgs,
+): Promise<ChartOfAccountsPageDto> {
+  const q = new URLSearchParams();
+  q.set('offset', String(args.offset ?? 0));
+  q.set('limit', String(args.limit ?? 20));
+  if (args.search) q.set('search', args.search);
+
+  if (args.includeDeleted != null) q.set('includeDeleted', String(args.includeDeleted));
+  if (args.onlyActive != null) q.set('onlyActive', String(args.onlyActive));
+  if (args.onlyDeleted != null) q.set('onlyDeleted', String(args.onlyDeleted));
+
+  const qs = q.toString();
+  return await httpGet<ChartOfAccountsPageDto>(`/api/chart-of-accounts${qs ? `?${qs}` : ''}`);
+}
+
+export async function getChartOfAccountsMetadata(): Promise<ChartOfAccountsMetadataDto> {
+  return await httpGet<ChartOfAccountsMetadataDto>('/api/chart-of-accounts/metadata');
+}
+
+export async function getChartOfAccountById(accountId: string): Promise<ChartOfAccountsAccountDto> {
+  return await httpGet<ChartOfAccountsAccountDto>(`/api/chart-of-accounts/${encodeURIComponent(accountId)}`);
+}
+
+export async function getChartOfAccountsByIds(ids: string[]): Promise<LookupItemDto[]> {
+  const request: ByIdsRequestDto = { ids }
+  return await httpPost<LookupItemDto[]>('/api/chart-of-accounts/by-ids', request);
+}
+
+export async function createChartOfAccount(
+  request: ChartOfAccountsUpsertRequestDto,
+): Promise<ChartOfAccountsAccountDto> {
+  return await httpPost<ChartOfAccountsAccountDto>('/api/chart-of-accounts', request);
+}
+
+export async function updateChartOfAccount(
+  accountId: string,
+  request: ChartOfAccountsUpsertRequestDto,
+): Promise<ChartOfAccountsAccountDto> {
+  return await httpPut<ChartOfAccountsAccountDto>(
+    `/api/chart-of-accounts/${encodeURIComponent(accountId)}`,
+    request,
+  );
+}
+
+export async function markChartOfAccountForDeletion(accountId: string): Promise<void> {
+  await httpPost<void>(`/api/chart-of-accounts/${encodeURIComponent(accountId)}/mark-for-deletion`);
+}
+
+export async function unmarkChartOfAccountForDeletion(accountId: string): Promise<void> {
+  await httpPost<void>(`/api/chart-of-accounts/${encodeURIComponent(accountId)}/unmark-for-deletion`);
+}
+
+export async function setChartOfAccountActive(
+  accountId: string,
+  isActive: boolean,
+): Promise<void> {
+  await httpPost<void>(
+    `/api/chart-of-accounts/${encodeURIComponent(accountId)}/set-active?isActive=${encodeURIComponent(String(isActive))}`,
+  );
+}

package/src/ngb/accounting/generalJournalEntry.ts

@@ -0,0 +1,127 @@
+import { normalizeDateOnlyValue, toDateOnlyValue } from '../utils/dateValues';
+import type { GeneralJournalEntryEditorLineModel } from './generalJournalEntryTypes';
+
+function randomToken(): string {
+  return Math.random().toString(36).slice(2, 8);
+}
+
+export function createGeneralJournalEntryLineKey(prefix = 'line'): string {
+  return `${prefix}-${Date.now().toString(36)}-${randomToken()}`;
+}
+
+export function createGeneralJournalEntryLine(
+  clientKey = createGeneralJournalEntryLineKey(),
+): GeneralJournalEntryEditorLineModel {
+  return {
+    clientKey,
+    side: 1,
+    account: null,
+    amount: '',
+    memo: '',
+    dimensions: {},
+  };
+}
+
+export function parseGeneralJournalEntryAmount(value: string): number {
+  const normalized = String(value ?? '').trim().replace(/,/g, '');
+  const amount = Number(normalized);
+  return Number.isFinite(amount) ? amount : Number.NaN;
+}
+
+export function formatGeneralJournalEntryMoney(value: number): string {
+  const amount = Number.isFinite(value) ? value : 0;
+  return amount.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+
+export function todayDateOnly(now = new Date()): string {
+  return toDateOnlyValue(now);
+}
+
+export function normalizeDateOnly(value: string | null | undefined): string | null {
+  const normalized = normalizeDateOnlyValue(value);
+  if (normalized) return normalized;
+
+  const raw = String(value ?? '').trim();
+  if (!raw) return null;
+
+  const date = new Date(raw);
+  if (Number.isNaN(date.getTime())) return null;
+  return date.toISOString().slice(0, 10);
+}
+
+export function toUtcMidday(dateOnly: string | null | undefined): string {
+  const normalized = normalizeDateOnly(dateOnly);
+  if (!normalized) throw new Error('Date is required.');
+  return `${normalized}T12:00:00Z`;
+}
+
+export function normalizeGeneralJournalEntryApprovalState(value: unknown): number {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+
+  const raw = String(value ?? '').trim().toLowerCase();
+  switch (raw) {
+    case '1':
+    case 'draft':
+      return 1;
+    case '2':
+    case 'submitted':
+      return 2;
+    case '3':
+    case 'approved':
+      return 3;
+    case '4':
+    case 'rejected':
+      return 4;
+    default:
+      return 1;
+  }
+}
+
+export function normalizeGeneralJournalEntrySource(value: unknown): number {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+
+  const raw = String(value ?? '').trim().toLowerCase();
+  switch (raw) {
+    case '2':
+    case 'system':
+      return 2;
+    case '1':
+    case 'manual':
+    default:
+      return 1;
+  }
+}
+
+export function generalJournalEntryApprovalStateLabel(value: unknown): string {
+  switch (normalizeGeneralJournalEntryApprovalState(value)) {
+    case 2:
+      return 'Submitted';
+    case 3:
+      return 'Approved';
+    case 4:
+      return 'Rejected';
+    default:
+      return 'Draft';
+  }
+}
+
+export function generalJournalEntrySourceLabel(value: unknown): string {
+  return normalizeGeneralJournalEntrySource(value) === 2 ? 'System' : 'Manual';
+}
+
+export function generalJournalEntryJournalTypeLabel(value: unknown): string {
+  switch (Number(value)) {
+    case 1:
+      return 'Standard';
+    case 2:
+      return 'Reversing';
+    case 3:
+      return 'Adjusting';
+    case 4:
+      return 'Opening';
+    case 5:
+      return 'Closing';
+    default:
+      return '—';
+  }
+}

package/src/ngb/accounting/generalJournalEntryApi.ts

@@ -0,0 +1,112 @@
+import { httpGet, httpPost, httpPut } from '../api/http';
+import type {
+  CreateGeneralJournalEntryDraftRequestDto,
+  GeneralJournalEntryAccountContextDto,
+  GeneralJournalEntryApproveRequestDto,
+  GeneralJournalEntryDetailsDto,
+  GeneralJournalEntryPageDto,
+  GeneralJournalEntryPostRequestDto,
+  GeneralJournalEntryRejectRequestDto,
+  GeneralJournalEntryReverseRequestDto,
+  GeneralJournalEntrySubmitRequestDto,
+  ReplaceGeneralJournalEntryLinesRequestDto,
+  UpdateGeneralJournalEntryHeaderRequestDto,
+} from './generalJournalEntryTypes';
+
+const base = '/api/accounting/general-journal-entries';
+
+export type GetGeneralJournalEntryPageArgs = {
+  offset?: number;
+  limit?: number;
+  search?: string | null;
+  dateFrom?: string | null;
+  dateTo?: string | null;
+  trash?: 'active' | 'deleted' | 'all' | null;
+};
+
+export async function getGeneralJournalEntryPage(
+  args: GetGeneralJournalEntryPageArgs,
+): Promise<GeneralJournalEntryPageDto> {
+  const q = new URLSearchParams();
+  q.set('offset', String(args.offset ?? 0));
+  q.set('limit', String(args.limit ?? 50));
+  if (args.search) q.set('search', args.search);
+  if (args.dateFrom) q.set('dateFrom', args.dateFrom);
+  if (args.dateTo) q.set('dateTo', args.dateTo);
+  if (args.trash) q.set('trash', args.trash);
+  const qs = q.toString();
+  return await httpGet<GeneralJournalEntryPageDto>(`${base}${qs ? `?${qs}` : ''}`);
+}
+
+export async function getGeneralJournalEntry(id: string): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpGet<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}`);
+}
+
+export async function createGeneralJournalEntryDraft(
+  request: CreateGeneralJournalEntryDraftRequestDto,
+): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPost<GeneralJournalEntryDetailsDto>(base, request);
+}
+
+export async function updateGeneralJournalEntryHeader(
+  id: string,
+  request: UpdateGeneralJournalEntryHeaderRequestDto,
+): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPut<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/header`, request);
+}
+
+export async function replaceGeneralJournalEntryLines(
+  id: string,
+  request: ReplaceGeneralJournalEntryLinesRequestDto,
+): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPut<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/lines`, request);
+}
+
+export async function submitGeneralJournalEntry(
+  id: string,
+  request: GeneralJournalEntrySubmitRequestDto,
+): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPost<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/submit`, request);
+}
+
+export async function approveGeneralJournalEntry(
+  id: string,
+  request: GeneralJournalEntryApproveRequestDto,
+): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPost<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/approve`, request);
+}
+
+export async function rejectGeneralJournalEntry(
+  id: string,
+  request: GeneralJournalEntryRejectRequestDto,
+): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPost<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/reject`, request);
+}
+
+export async function postGeneralJournalEntry(
+  id: string,
+  request: GeneralJournalEntryPostRequestDto,
+): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPost<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/post`, request);
+}
+
+export async function reverseGeneralJournalEntry(
+  id: string,
+  request: GeneralJournalEntryReverseRequestDto,
+): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPost<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/reverse`, request);
+}
+
+export async function getGeneralJournalEntryAccountContext(
+  accountId: string,
+): Promise<GeneralJournalEntryAccountContextDto> {
+  return await httpGet<GeneralJournalEntryAccountContextDto>(`${base}/accounts/${encodeURIComponent(accountId)}`);
+}
+
+export async function markGeneralJournalEntryForDeletion(id: string): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPost<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/mark-for-deletion`);
+}
+
+export async function unmarkGeneralJournalEntryForDeletion(id: string): Promise<GeneralJournalEntryDetailsDto> {
+  return await httpPost<GeneralJournalEntryDetailsDto>(`${base}/${encodeURIComponent(id)}/unmark-for-deletion`);
+}

package/src/ngb/accounting/generalJournalEntryTypes.ts

@@ -0,0 +1,155 @@
+import type { LookupItem, LookupSource } from '../metadata/types';
+
+export type GeneralJournalEntryDimensionValueDto = {
+  dimensionId: string;
+  valueId: string;
+  display?: string | null;
+};
+
+export type GeneralJournalEntryLineDto = {
+  lineNo: number;
+  side: number;
+  accountId: string;
+  accountDisplay?: string | null;
+  amount: number;
+  memo?: string | null;
+  dimensionSetId: string;
+  dimensions: GeneralJournalEntryDimensionValueDto[];
+};
+
+export type GeneralJournalEntryAllocationDto = {
+  entryNo: number;
+  debitLineNo: number;
+  creditLineNo: number;
+  amount: number;
+};
+
+export type GeneralJournalEntryHeaderDto = {
+  journalType: number;
+  source: number;
+  approvalState: number;
+  reasonCode?: string | null;
+  memo?: string | null;
+  externalReference?: string | null;
+  autoReverse: boolean;
+  autoReverseOnUtc?: string | null;
+  reversalOfDocumentId?: string | null;
+  reversalOfDocumentDisplay?: string | null;
+  initiatedBy?: string | null;
+  initiatedAtUtc?: string | null;
+  submittedBy?: string | null;
+  submittedAtUtc?: string | null;
+  approvedBy?: string | null;
+  approvedAtUtc?: string | null;
+  rejectedBy?: string | null;
+  rejectedAtUtc?: string | null;
+  rejectReason?: string | null;
+  postedBy?: string | null;
+  postedAtUtc?: string | null;
+  createdAtUtc: string;
+  updatedAtUtc: string;
+};
+
+export type GeneralJournalEntryListItemDto = {
+  id: string;
+  dateUtc: string;
+  number?: string | null;
+  display?: string | null;
+  documentStatus: number | string;
+  isMarkedForDeletion: boolean;
+  journalType: number;
+  source: number;
+  approvalState: number;
+  reasonCode?: string | null;
+  memo?: string | null;
+  externalReference?: string | null;
+  autoReverse: boolean;
+  autoReverseOnUtc?: string | null;
+  reversalOfDocumentId?: string | null;
+  postedBy?: string | null;
+  postedAtUtc?: string | null;
+};
+
+export type GeneralJournalEntryPageDto = {
+  items: GeneralJournalEntryListItemDto[];
+  offset: number;
+  limit: number;
+  total?: number | null;
+};
+
+export type GeneralJournalEntryDocumentDto = {
+  id: string;
+  display?: string | null;
+  status: number | string;
+  isMarkedForDeletion: boolean;
+  number?: string | null;
+};
+
+export type GeneralJournalEntryDetailsDto = {
+  document: GeneralJournalEntryDocumentDto;
+  dateUtc: string;
+  header: GeneralJournalEntryHeaderDto;
+  lines: GeneralJournalEntryLineDto[];
+  allocations: GeneralJournalEntryAllocationDto[];
+  accountContexts?: GeneralJournalEntryAccountContextDto[];
+};
+
+export type GeneralJournalEntryDimensionRuleDto = {
+  dimensionId: string;
+  dimensionCode: string;
+  ordinal: number;
+  isRequired: boolean;
+  lookup?: LookupSource | null;
+};
+
+export type GeneralJournalEntryAccountContextDto = {
+  accountId: string;
+  code: string;
+  name: string;
+  dimensionRules: GeneralJournalEntryDimensionRuleDto[];
+};
+
+export type CreateGeneralJournalEntryDraftRequestDto = {
+  dateUtc: string;
+};
+
+export type UpdateGeneralJournalEntryHeaderRequestDto = {
+  updatedBy: string;
+  journalType?: number | null;
+  reasonCode?: string | null;
+  memo?: string | null;
+  externalReference?: string | null;
+  autoReverse?: boolean | null;
+  autoReverseOnUtc?: string | null;
+};
+
+export type GeneralJournalEntryLineInputDto = {
+  side: number;
+  accountId: string;
+  amount: number;
+  memo?: string | null;
+  dimensions?: GeneralJournalEntryDimensionValueDto[] | null;
+};
+
+export type ReplaceGeneralJournalEntryLinesRequestDto = {
+  updatedBy: string;
+  lines: GeneralJournalEntryLineInputDto[];
+};
+
+export type GeneralJournalEntrySubmitRequestDto = Record<string, never>;
+export type GeneralJournalEntryApproveRequestDto = Record<string, never>;
+export type GeneralJournalEntryPostRequestDto = Record<string, never>;
+export type GeneralJournalEntryRejectRequestDto = { rejectReason: string };
+export type GeneralJournalEntryReverseRequestDto = {
+  reversalDateUtc: string;
+  postImmediately?: boolean;
+};
+
+export type GeneralJournalEntryEditorLineModel = {
+  clientKey: string;
+  side: number;
+  account: LookupItem | null;
+  amount: string;
+  memo: string;
+  dimensions: Record<string, LookupItem | null>;
+};

package/src/ngb/accounting/navigation.ts

@@ -0,0 +1,83 @@
+export const DEFAULT_CHART_OF_ACCOUNTS_BASE_PATH = '/admin/chart-of-accounts';
+export const DEFAULT_GENERAL_JOURNAL_ENTRIES_BASE_PATH = '/accounting/general-journal-entries';
+export const DEFAULT_ACCOUNTING_PERIOD_CLOSING_BASE_PATH = '/admin/accounting/period-closing';
+
+export type ChartOfAccountsRouteOptions = {
+  panel?: 'new' | 'edit' | null;
+  id?: string | null;
+  basePath?: string | null;
+};
+
+export type GeneralJournalEntriesRouteOptions = {
+  basePath?: string | null;
+};
+
+export type AccountingPeriodClosingRouteOptions = {
+  year?: string | number | null;
+  month?: string | null;
+  fy?: string | null;
+  basePath?: string | null;
+};
+
+const GENERAL_JOURNAL_ENTRY_DOCUMENT_TYPES = new Set([
+  'accounting.general_journal_entry',
+  'general_journal_entry',
+]);
+
+function normalizePathSegment(value: string | null | undefined): string {
+  return String(value ?? '').trim();
+}
+
+function appendQuery(path: string, query: Record<string, string | null | undefined>): string {
+  const params = new URLSearchParams();
+
+  for (const [key, value] of Object.entries(query)) {
+    const normalized = normalizePathSegment(value);
+    if (!normalized) continue;
+    params.set(key, normalized);
+  }
+
+  const serialized = params.toString();
+  return serialized ? `${path}?${serialized}` : path;
+}
+
+export function buildChartOfAccountsPath(options: ChartOfAccountsRouteOptions = {}): string {
+  return appendQuery(
+    normalizePathSegment(options.basePath) || DEFAULT_CHART_OF_ACCOUNTS_BASE_PATH,
+    {
+      panel: options.panel ?? undefined,
+      id: options.id ?? undefined,
+    },
+  );
+}
+
+export function isGeneralJournalEntryDocumentType(documentType: string | null | undefined): boolean {
+  return GENERAL_JOURNAL_ENTRY_DOCUMENT_TYPES.has(normalizePathSegment(documentType));
+}
+
+export function buildGeneralJournalEntriesListPath(options: GeneralJournalEntriesRouteOptions = {}): string {
+  return normalizePathSegment(options.basePath) || DEFAULT_GENERAL_JOURNAL_ENTRIES_BASE_PATH;
+}
+
+export function buildGeneralJournalEntriesPath(
+  id?: string | null,
+  options: GeneralJournalEntriesRouteOptions = {},
+): string {
+  const basePath = buildGeneralJournalEntriesListPath(options);
+  const normalizedId = normalizePathSegment(id);
+  if (!normalizedId) return `${basePath}/new`;
+  return `${basePath}/${encodeURIComponent(normalizedId)}`;
+}
+
+export function buildAccountingPeriodClosingPath(
+  options: AccountingPeriodClosingRouteOptions = {},
+): string {
+  return appendQuery(
+    normalizePathSegment(options.basePath) || DEFAULT_ACCOUNTING_PERIOD_CLOSING_BASE_PATH,
+    {
+      year: options.year == null ? undefined : String(options.year),
+      month: options.month ?? undefined,
+      fy: options.fy ?? undefined,
+    },
+  );
+}

package/src/ngb/accounting/periodClosing.ts

@@ -0,0 +1,75 @@
+import {
+  currentMonthValue,
+  dateOnlyToMonthValue,
+  formatMonthValue,
+  monthValueToDateOnly,
+  monthValueYear,
+  normalizeMonthValue,
+} from '../utils/dateValues';
+import {
+  normalizeMonthQueryValue,
+  normalizeYearQueryValue,
+} from '../router/queryParams';
+
+type PeriodClosingQueryLike = {
+  year?: unknown;
+  month?: unknown;
+  fy?: unknown;
+};
+
+export function currentCalendarYear(now = new Date()): number {
+  return now.getFullYear();
+}
+
+export function defaultMonthValueForYear(year: number, now = new Date()): string {
+  const current = currentMonthValue(now);
+  return monthValueYear(current) === year ? current : `${year}-01`;
+}
+
+export function alignMonthValueToYear(
+  monthValue: string | null | undefined,
+  year: number,
+  now = new Date(),
+): string {
+  const normalized = normalizeMonthValue(monthValue) ?? defaultMonthValueForYear(year, now);
+  return `${year}-${normalized.slice(5, 7)}`;
+}
+
+export function resolveSelectedYear(query: PeriodClosingQueryLike, now = new Date()): number {
+  const explicitYear = normalizeYearQueryValue(query.year);
+  if (explicitYear) return explicitYear;
+
+  const monthYear = monthValueYear(normalizeMonthQueryValue(query.month));
+  if (monthYear) return monthYear;
+
+  const fiscalYear = monthValueYear(normalizeMonthQueryValue(query.fy));
+  if (fiscalYear) return fiscalYear;
+
+  return currentCalendarYear(now);
+}
+
+export function resolveSelectedMonthValue(
+  queryValue: unknown,
+  selectedYear: number,
+  now = new Date(),
+): string {
+  const fromQuery = normalizeMonthQueryValue(queryValue);
+  if (fromQuery && monthValueYear(fromQuery) === selectedYear) return fromQuery;
+  return defaultMonthValueForYear(selectedYear, now);
+}
+
+export function selectMonthValue(value: string | null | undefined): string | null {
+  return normalizeMonthValue(value) ?? dateOnlyToMonthValue(value);
+}
+
+export function toPeriodDateOnly(monthValue: string): string {
+  return monthValueToDateOnly(monthValue) ?? `${monthValue}-01`;
+}
+
+export function formatPeriodMonthValue(value: string | null | undefined): string {
+  return formatMonthValue(value) ?? '—';
+}
+
+export function formatPeriodDateOnly(value: string | null | undefined): string {
+  return formatPeriodMonthValue(dateOnlyToMonthValue(value));
+}

package/src/ngb/accounting/periodClosingApi.ts

@@ -0,0 +1,60 @@
+import { httpGet, httpPost } from '../api/http';
+import type {
+  CloseFiscalYearRequestDto,
+  CloseMonthRequestDto,
+  FiscalYearCloseStatusDto,
+  PeriodClosingCalendarDto,
+  PeriodCloseStatusDto,
+  ReopenFiscalYearRequestDto,
+  ReopenMonthRequestDto,
+  RetainedEarningsAccountOptionDto,
+} from './periodClosingTypes';
+
+export async function getMonthCloseStatus(period: string): Promise<PeriodCloseStatusDto> {
+  return await httpGet<PeriodCloseStatusDto>('/api/accounting/period-closing/month', { period });
+}
+
+export async function closeMonth(request: CloseMonthRequestDto): Promise<PeriodCloseStatusDto> {
+  return await httpPost<PeriodCloseStatusDto>('/api/accounting/period-closing/month/close', request);
+}
+
+export async function reopenMonth(request: ReopenMonthRequestDto): Promise<PeriodCloseStatusDto> {
+  return await httpPost<PeriodCloseStatusDto>('/api/accounting/period-closing/month/reopen', request);
+}
+
+export async function getPeriodClosingCalendar(year: number): Promise<PeriodClosingCalendarDto> {
+  return await httpGet<PeriodClosingCalendarDto>('/api/accounting/period-closing/calendar', { year });
+}
+
+export async function getFiscalYearCloseStatus(
+  fiscalYearEndPeriod: string,
+): Promise<FiscalYearCloseStatusDto> {
+  return await httpGet<FiscalYearCloseStatusDto>('/api/accounting/period-closing/fiscal-year', {
+    fiscalYearEndPeriod,
+  });
+}
+
+export async function closeFiscalYear(
+  request: CloseFiscalYearRequestDto,
+): Promise<FiscalYearCloseStatusDto> {
+  return await httpPost<FiscalYearCloseStatusDto>('/api/accounting/period-closing/fiscal-year/close', request);
+}
+
+export async function reopenFiscalYear(
+  request: ReopenFiscalYearRequestDto,
+): Promise<FiscalYearCloseStatusDto> {
+  return await httpPost<FiscalYearCloseStatusDto>('/api/accounting/period-closing/fiscal-year/reopen', request);
+}
+
+export async function searchRetainedEarningsAccounts(args?: {
+  query?: string | null;
+  limit?: number;
+}): Promise<RetainedEarningsAccountOptionDto[]> {
+  return await httpGet<RetainedEarningsAccountOptionDto[]>(
+    '/api/accounting/period-closing/retained-earnings-accounts',
+    {
+      q: args?.query?.trim() || undefined,
+      limit: args?.limit ?? 20,
+    },
+  );
+}