@fin.cx/skr/dist_ts/skr.api.d.ts

SKR03 and SKR04 German accounting standards for double-entry bookkeeping

import { Account } from './skr.classes.account.js';
import { Transaction } from './skr.classes.transaction.js';
import { JournalEntry } from './skr.classes.journalentry.js';
import { type IExportOptions } from './skr.export.js';
import { type IBookingOptions, type IBookingResult } from './skr.invoice.booking.js';
import type { IInvoice, IInvoiceFilter, IInvoiceImportOptions, IInvoiceExportOptions, IBookingRules, TInvoiceDirection } from './skr.invoice.entity.js';
import type { IDatabaseConfig, TSKRType, IAccountData, IAccountFilter, ITransactionData, ITransactionFilter, IJournalEntry, IReportParams, ITrialBalanceReport, IIncomeStatement, IBalanceSheet } from './skr.types.js';
/**
 * Main API class for SKR accounting operations
 */
export declare class SkrApi {
    private config;
    private chartOfAccounts;
    private ledger;
    private reports;
    private logger;
    private initialized;
    private currentSKRType;
    private invoiceAdapter;
    private invoiceStorage;
    private invoiceBookingEngine;
    constructor(config: IDatabaseConfig);
    /**
     * Initialize the API with specified SKR type
     */
    initialize(skrType: TSKRType): Promise<void>;
    /**
     * Ensure API is initialized
     */
    private ensureInitialized;
    /**
     * Create a new account
     */
    createAccount(accountData: Partial<IAccountData>): Promise<Account>;
    /**
     * Get account by number
     */
    getAccount(accountNumber: string): Promise<Account | null>;
    /**
     * Update an account
     */
    updateAccount(accountNumber: string, updates: Partial<IAccountData>): Promise<Account>;
    /**
     * Delete an account
     */
    deleteAccount(accountNumber: string): Promise<void>;
    /**
     * List accounts with optional filter
     */
    listAccounts(filter?: IAccountFilter): Promise<Account[]>;
    /**
     * Search accounts by term
     */
    searchAccounts(searchTerm: string): Promise<Account[]>;
    /**
     * Get accounts by class
     */
    getAccountsByClass(accountClass: number): Promise<Account[]>;
    /**
     * Get accounts by type
     */
    getAccountsByType(accountType: IAccountData['accountType']): Promise<Account[]>;
    /**
     * Post a simple transaction
     */
    postTransaction(transactionData: ITransactionData): Promise<Transaction>;
    /**
     * Post a journal entry
     */
    postJournalEntry(journalData: IJournalEntry): Promise<JournalEntry>;
    /**
     * Get transaction by ID
     */
    getTransaction(transactionId: string): Promise<Transaction | null>;
    /**
     * List transactions with optional filter
     */
    listTransactions(filter?: ITransactionFilter): Promise<Transaction[]>;
    /**
     * Get transactions for specific account
     */
    getAccountTransactions(accountNumber: string): Promise<Transaction[]>;
    /**
     * Reverse a transaction
     */
    reverseTransaction(transactionId: string): Promise<Transaction>;
    /**
     * Reverse a journal entry
     */
    reverseJournalEntry(journalId: string): Promise<JournalEntry>;
    /**
     * Generate trial balance
     */
    generateTrialBalance(params?: IReportParams): Promise<ITrialBalanceReport>;
    /**
     * Generate income statement
     */
    generateIncomeStatement(params?: IReportParams): Promise<IIncomeStatement>;
    /**
     * Generate balance sheet
     */
    generateBalanceSheet(params?: IReportParams): Promise<IBalanceSheet>;
    /**
     * Generate general ledger
     */
    generateGeneralLedger(params?: IReportParams): Promise<any>;
    /**
     * Generate cash flow statement
     */
    generateCashFlowStatement(params?: IReportParams): Promise<any>;
    /**
     * Export report to CSV
     */
    exportReportToCSV(reportType: 'trial_balance' | 'income_statement' | 'balance_sheet', params?: IReportParams): Promise<string>;
    /**
     * Export to DATEV format
     */
    exportToDATEV(params?: IReportParams): Promise<string>;
    /**
     * Close accounting period
     */
    closePeriod(period: string, closingAccountNumber?: string): Promise<JournalEntry[]>;
    /**
     * Get account balance
     */
    getAccountBalance(accountNumber: string, asOfDate?: Date): Promise<any>;
    /**
     * Recalculate all account balances
     */
    recalculateBalances(): Promise<void>;
    /**
     * Import accounts from CSV
     */
    importAccountsFromCSV(csvContent: string): Promise<number>;
    /**
     * Export accounts to CSV
     */
    exportAccountsToCSV(): Promise<string>;
    /**
     * Export Jahresabschluss in GoBD-compliant BagIt format
     * Creates a revision-safe export for 10-year archival
     */
    exportJahresabschluss(options: IExportOptions): Promise<string>;
    /**
     * Export ledger data in NDJSON format
     */
    private exportLedgerData;
    /**
     * Export account data in CSV format
     */
    private exportAccountData;
    /**
     * Export balance data in CSV format
     */
    private exportBalanceData;
    /**
     * Generate PDF reports for the export
     */
    private generatePdfReports;
    /**
     * Sign the export with CAdES signature
     */
    private signExport;
    /**
     * Get current SKR type
     */
    getSKRType(): TSKRType | null;
    /**
     * Get account class description
     */
    getAccountClassDescription(accountClass: number): string;
    /**
     * Validate double-entry rules
     */
    validateDoubleEntry(debitAmount: number, creditAmount: number): boolean;
    /**
     * Get unbalanced transactions (for audit)
     */
    getUnbalancedTransactions(): Promise<Transaction[]>;
    /**
     * Close the API and database connection
     */
    close(): Promise<void>;
    /**
     * Post multiple transactions
     */
    postBatchTransactions(transactions: ITransactionData[]): Promise<Transaction[]>;
    /**
     * Create multiple accounts
     */
    createBatchAccounts(accounts: IAccountData[]): Promise<Account[]>;
    /**
     * Get paginated accounts
     */
    getAccountsPaginated(page?: number, pageSize?: number, filter?: IAccountFilter): Promise<{
        data: Account[];
        total: number;
        page: number;
        pageSize: number;
        totalPages: number;
    }>;
    /**
     * Get paginated transactions
     */
    getTransactionsPaginated(page?: number, pageSize?: number, filter?: ITransactionFilter): Promise<{
        data: Transaction[];
        total: number;
        page: number;
        pageSize: number;
        totalPages: number;
    }>;
    /**
     * Import an invoice from file or buffer
     * Parses, validates, and optionally books the invoice
     */
    importInvoice(file: Buffer | string, direction: TInvoiceDirection, options?: IInvoiceImportOptions): Promise<IInvoice>;
    /**
     * Book an invoice to the ledger
     */
    bookInvoice(invoice: IInvoice, bookingRules?: Partial<IBookingRules>, options?: IBookingOptions): Promise<IBookingResult>;
    /**
     * Export an invoice in a different format
     */
    exportInvoice(invoice: IInvoice, options: IInvoiceExportOptions): Promise<{
        xml: string;
        pdf?: Buffer;
    }>;
    /**
     * Search invoices by filter
     */
    searchInvoices(filter: IInvoiceFilter): Promise<IInvoice[]>;
    /**
     * Get invoice by content hash
     */
    getInvoice(contentHash: string): Promise<IInvoice | null>;
    /**
     * Get invoice storage statistics
     */
    getInvoiceStatistics(): Promise<any>;
    /**
     * Create EN16931 compliance report for invoices
     */
    createInvoiceComplianceReport(): Promise<void>;
    /**
     * Generate an invoice from internal data
     */
    generateInvoice(invoiceData: Partial<IInvoice>, format: IInvoiceExportOptions['format']): Promise<{
        xml: string;
        pdf?: Buffer;
    }>;
}