ohadakit 1.0.0

package/dist/types/AccountBook.d.ts

@@ -0,0 +1,58 @@
+import type { Account } from './core/Account';
+import { type AccountRegistry } from './core/AccountRegistry';
+import { QueryBuilder } from './query/QueryEngine';
+import { CustomAccountManager } from './custom/CustomAccountManager';
+import { TranslationService } from './i18n/TranslationService';
+import type { Result, StorageAdapter, AccountBookOptions, AccountBookSnapshot, AccountBookStats, JsonExportOptions, CsvExportOptions, OhadaLocale } from './core/types';
+import type { CustomAccountInput, LabelOverride } from './custom/types';
+export declare class AccountBook {
+    readonly registry: AccountRegistry;
+    readonly customManager: CustomAccountManager;
+    readonly i18n: TranslationService;
+    private readonly storage;
+    private readonly storagePrefix;
+    private readonly notesCache;
+    private notesCacheLoaded;
+    private initialized;
+    constructor(options: AccountBookOptions);
+    initialize(): Promise<void>;
+    isInitialized(): boolean;
+    getAccount(code: string): Result<Account>;
+    getAccountOrNull(code: string): Account | null;
+    getAccountOrThrow(code: string): Account;
+    has(code: string): boolean;
+    getAllAccounts(): Account[];
+    query(): QueryBuilder;
+    createAccount(input: CustomAccountInput): Promise<Result<Account>>;
+    deleteAccount(code: string): Promise<Result<void>>;
+    updateLabel(code: string, newLabel: string): Promise<Result<Account>>;
+    getCustomAccounts(): Account[];
+    getLabelOverrides(): LabelOverride[];
+    setNote(code: string, note: string): Promise<void>;
+    getNote(code: string): Promise<string | null>;
+    deleteNote(code: string): Promise<void>;
+    getAllNotes(): Promise<Map<string, string>>;
+    clearAllNotes(): Promise<void>;
+    getLocalizedName(code: string): string | null;
+    getLocale(): OhadaLocale;
+    setLocale(locale: OhadaLocale): void;
+    getAvailableLocales(): OhadaLocale[];
+    exportToJSON(options?: JsonExportOptions): string;
+    exportToCSV(options?: CsvExportOptions): string;
+    exportClass(classCode: string, format: 'json', options?: JsonExportOptions): string;
+    exportClass(classCode: string, format: 'csv', options?: CsvExportOptions): string;
+    snapshot(): Promise<AccountBookSnapshot>;
+    restore(snap: AccountBookSnapshot): Promise<Result<void>>;
+    getStats(): Promise<AccountBookStats>;
+    private ensureInitialized;
+    private notesKey;
+    private loadNotesCache;
+    private validateSnapshotShape;
+}
+export interface CreateAccountBookOptions {
+    storage?: StorageAdapter;
+    locale?: OhadaLocale;
+    storagePrefix?: string;
+}
+export declare function createAccountBook(options?: CreateAccountBookOptions): AccountBook;
+//# sourceMappingURL=AccountBook.d.ts.map

package/dist/types/LedgerEngine.d.ts

@@ -0,0 +1,45 @@
+import { Account } from './core/Account';
+import { AccountRegistry } from './core/AccountRegistry';
+import { QueryBuilder } from './query/QueryEngine';
+import type { Result, LedgerEngineOptions, StorageAdapter, RegistryStats, JsonExportOptions, CsvExportOptions, OhadaLocale } from './core/types';
+import { TranslationService } from './i18n/TranslationService';
+export declare class LedgerEngine {
+    readonly registry: AccountRegistry;
+    readonly storage: StorageAdapter;
+    readonly i18n: TranslationService;
+    constructor(options?: LedgerEngineOptions);
+    get(code: string): Result<Account>;
+    getOrThrow(code: string): Account;
+    getOrNull(code: string): Account | null;
+    query(): QueryBuilder;
+    validateBatch(codes: string[]): {
+        valid: Array<{
+            code: string;
+            account: Account;
+        }>;
+        invalid: Array<{
+            code: string;
+            error: Error;
+        }>;
+    };
+    getNote(code: string): Promise<string | null>;
+    setNote(code: string, note: string): Promise<void>;
+    deleteNote(code: string): Promise<void>;
+    getAllNotes(): Promise<Map<string, string>>;
+    clearAllNotes(): Promise<void>;
+    hasNote(code: string): Promise<boolean>;
+    export(format: 'json', options?: JsonExportOptions): string;
+    export(format: 'csv', options?: CsvExportOptions): string;
+    exportToJSON(options?: JsonExportOptions): string;
+    exportToCSV(options?: CsvExportOptions): string;
+    exportClass(classCode: string, format: 'json', options?: JsonExportOptions): string;
+    exportClass(classCode: string, format: 'csv', options?: CsvExportOptions): string;
+    getLocalizedName(code: string): string | null;
+    getLocale(): OhadaLocale;
+    setLocale(locale: OhadaLocale): void;
+    getAvailableLocales(): OhadaLocale[];
+    getStats(): RegistryStats;
+}
+export declare function createLedgerEngine(options?: LedgerEngineOptions): LedgerEngine;
+export declare function getDefaultLedgerEngine(): LedgerEngine;
+//# sourceMappingURL=LedgerEngine.d.ts.map

package/dist/types/core/Account.d.ts

@@ -0,0 +1,49 @@
+import type { AccountCode, RawAccountData, AccountJSON, AccountMetadata, ClassCode } from './types';
+export declare class Account {
+    readonly code: AccountCode;
+    readonly name: string;
+    readonly level: 1 | 2 | 3 | 4;
+    readonly classCode: ClassCode;
+    readonly parentCode?: AccountCode;
+    readonly metadata?: AccountMetadata;
+    private _registry?;
+    private _parent?;
+    private _children?;
+    private _ancestors?;
+    private _siblings?;
+    private _path?;
+    private _pathString?;
+    private _pathCodes?;
+    constructor(data: RawAccountData, metadata?: AccountMetadata);
+    _setRegistry(registry: AccountRegistry): void;
+    get parent(): Account | null;
+    get children(): Account[];
+    get ancestors(): Account[];
+    get siblings(): Account[];
+    get path(): Account[];
+    get pathString(): string;
+    get pathCodes(): string[];
+    get classAccount(): Account | null;
+    get isLeaf(): boolean;
+    get isRoot(): boolean;
+    isDescendantOf(code: string): boolean;
+    isAncestorOf(code: string): boolean;
+    isSiblingOf(code: string): boolean;
+    get depth(): number;
+    getDescendants(): Account[];
+    getDescendantsAtLevel(relativeLevel: number): Account[];
+    toJSON(): AccountJSON;
+    toRawData(): RawAccountData;
+    toString(): string;
+    toDetailedString(): string;
+    static fromRawData(data: RawAccountData, metadata?: AccountMetadata): Account;
+    static fromJSON(json: AccountJSON): Account;
+}
+export declare function isAccount(value: unknown): value is Account;
+interface AccountRegistry {
+    getByCode(code: AccountCode): Account | null;
+    getChildren(code: AccountCode): Account[];
+    getByLevel(level: number): Account[];
+}
+export {};
+//# sourceMappingURL=Account.d.ts.map

package/dist/types/core/AccountIndex.d.ts

@@ -0,0 +1,31 @@
+import type { Account } from './Account';
+export declare class AccountIndex {
+    private byCode;
+    private byClass;
+    private byLevel;
+    private byParent;
+    private codeTrie;
+    private nameIndex;
+    constructor(accounts?: Account[]);
+    private addAccount;
+    private indexAccountName;
+    get(code: string): Account | null;
+    has(code: string): boolean;
+    getByClass(classCode: string): Account[];
+    getByLevel(level: number): Account[];
+    getChildren(code: string): Account[];
+    getAll(): Account[];
+    searchByPrefix(prefix: string): Account[];
+    searchByName(query: string, options?: {
+        limit?: number;
+    }): Account[];
+    searchByNameFuzzy(query: string, threshold?: number, limit?: number): Account[];
+    private fuzzyMatch;
+    private levenshteinDistance;
+    get size(): number;
+    getClassCounts(): Map<string, number>;
+    getLevelCounts(): Map<number, number>;
+    clear(): void;
+    rebuild(accounts: Account[]): void;
+}
+//# sourceMappingURL=AccountIndex.d.ts.map

package/dist/types/core/AccountRegistry.d.ts

@@ -0,0 +1,39 @@
+import { Account } from './Account';
+import type { AccountCode, RawAccountData, RegistryStats, OhadaClass } from './types';
+export declare class AccountRegistry {
+    private accounts;
+    private index;
+    private initialized;
+    constructor(accountsData?: RawAccountData[]);
+    getByCode(code: string): Account | null;
+    has(code: string): boolean;
+    getByClass(classCode: string): Account[];
+    getByLevel(level: number): Account[];
+    getChildren(code: string | AccountCode): Account[];
+    getAll(): Account[];
+    searchByPrefix(prefix: string): Account[];
+    searchByName(query: string, options?: {
+        limit?: number;
+    }): Account[];
+    searchByNameFuzzy(query: string, threshold?: number, limit?: number): Account[];
+    getClassMetadata(classCode: string): OhadaClass | null;
+    getClassRoot(classCode: string): Account | null;
+    getMainAccounts(classCode: string): Account[];
+    getStats(): RegistryStats;
+    get size(): number;
+    get isInitialized(): boolean;
+    getLeafAccounts(): Account[];
+    getRootAccounts(): Account[];
+    getByLevelRange(minLevel: number, maxLevel: number): Account[];
+    getSubtree(code: string): Account[];
+    getSiblings(code: string): Account[];
+    getAncestors(code: string): Account[];
+    getPath(code: string): Account[];
+    validateIntegrity(): {
+        valid: boolean;
+        errors: string[];
+    };
+}
+export declare function getDefaultRegistry(): AccountRegistry;
+export declare function resetDefaultRegistry(): void;
+//# sourceMappingURL=AccountRegistry.d.ts.map

package/dist/types/core/types.d.ts

@@ -0,0 +1,127 @@
+export type OhadaLocale = 'fr' | 'en' | 'pt' | 'es';
+export type AccountCode = string & {
+    readonly __brand: 'AccountCode';
+};
+export type ClassCode = string & {
+    readonly __brand: 'ClassCode';
+};
+export type Result<T, E = Error> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: E;
+};
+export declare function Ok<T, E = Error>(data: T): Result<T, E>;
+export declare function Err<E = Error>(error: E): Result<never, E>;
+export interface RawAccountData {
+    code: string;
+    name: string;
+    level: 1 | 2 | 3 | 4;
+    classCode: string;
+    parentCode?: string;
+}
+export interface AccountMetadata {
+    description?: string;
+    nameEn?: string;
+    descriptionEn?: string;
+    tags?: string[];
+    isCommon?: boolean;
+}
+export interface AccountJSON {
+    code: string;
+    name: string;
+    level: number;
+    classCode: string;
+    parentCode?: string;
+    path: string[];
+    pathString: string;
+    metadata?: AccountMetadata;
+}
+export interface OhadaClass {
+    code: ClassCode;
+    name: string;
+    nameEn: string;
+    description: string;
+    descriptionEn: string;
+}
+export interface QueryFilter {
+    class?: string | string[];
+    level?: number | number[];
+    parent?: string;
+    nameContains?: string;
+    codePattern?: RegExp;
+    predicate?: (account: any) => boolean;
+}
+export interface SearchOptions {
+    fuzzy?: boolean;
+    threshold?: number;
+    limit?: number;
+    caseSensitive?: boolean;
+    fields?: ('code' | 'name')[];
+}
+export interface SortOptions {
+    by: 'code' | 'name' | 'level';
+    direction: 'asc' | 'desc';
+}
+export interface RegistryStats {
+    total: number;
+    byClass: Record<string, number>;
+    byLevel: Record<number, number>;
+    mainAccounts: number;
+    subAccounts: number;
+    detailAccounts: number;
+}
+export type ExportFormat = 'json' | 'csv';
+export type JsonStructure = 'flat' | 'hierarchical';
+export interface JsonExportOptions {
+    structure?: JsonStructure;
+    pretty?: boolean;
+    includeNotes?: boolean;
+}
+export interface CsvExportOptions {
+    delimiter?: string;
+    includeHeader?: boolean;
+    columns?: string[];
+    includeNotes?: boolean;
+}
+export type ExportOptions = JsonExportOptions | CsvExportOptions;
+export interface StorageAdapter {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string): Promise<void>;
+    delete(key: string): Promise<void>;
+    getAll(): Promise<Map<string, string>>;
+    clear(): Promise<void>;
+}
+export interface LedgerEngineOptions {
+    storage?: StorageAdapter;
+    locale?: OhadaLocale;
+}
+export declare function isClassCode(value: unknown): value is ClassCode;
+export declare function isOk<T, E>(result: Result<T, E>): result is {
+    ok: true;
+    data: T;
+};
+export declare function isErr<T, E>(result: Result<T, E>): result is {
+    ok: false;
+    error: E;
+};
+export interface AccountBookOptions {
+    storage: StorageAdapter;
+    locale?: OhadaLocale;
+    storagePrefix?: string;
+}
+export interface AccountBookSnapshot {
+    version: number;
+    timestamp: string;
+    locale: OhadaLocale;
+    customAccounts: import('../custom/types').CustomAccountData[];
+    labelOverrides: import('../custom/types').LabelOverride[];
+    notes: Record<string, string>;
+}
+export interface AccountBookStats extends RegistryStats {
+    customAccountCount: number;
+    labelOverrideCount: number;
+    noteCount: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types/custom/CustomAccountIndex.d.ts

@@ -0,0 +1,28 @@
+import type { CustomAccountData } from './types';
+export declare class CustomAccountIndex {
+    private byCode;
+    private byClass;
+    private byParent;
+    constructor();
+    add(account: CustomAccountData): void;
+    remove(code: string): boolean;
+    update(account: CustomAccountData): void;
+    get(code: string): CustomAccountData | null;
+    has(code: string): boolean;
+    getAll(): CustomAccountData[];
+    getAllCodes(): string[];
+    getByClass(classCode: string): CustomAccountData[];
+    getByParent(parentCode: string): CustomAccountData[];
+    getChildrenCodes(parentCode: string): string[];
+    searchByName(query: string): CustomAccountData[];
+    searchByPrefix(prefix: string): CustomAccountData[];
+    get size(): number;
+    clear(): void;
+    rebuild(accounts: CustomAccountData[]): void;
+    getStats(): {
+        total: number;
+        byClass: Record<string, number>;
+    };
+    toMap(): Map<string, CustomAccountData>;
+}
+//# sourceMappingURL=CustomAccountIndex.d.ts.map

package/dist/types/custom/CustomAccountManager.d.ts

@@ -0,0 +1,44 @@
+import { Account } from '../core/Account';
+import { AccountRegistry } from '../core/AccountRegistry';
+import type { StorageAdapter } from '../core/types';
+import type { CustomAccountInput, CustomAccountData, CustomAccountManagerOptions, LabelOverride, CreateAccountResult, UpdateLabelResult, DeleteAccountResult, CustomAccountStats } from './types';
+export declare class CustomAccountManager {
+    private readonly baseRegistry;
+    private readonly storage;
+    private readonly storagePrefix;
+    private readonly customIndex;
+    private readonly labelOverrides;
+    private readonly validator;
+    private initialized;
+    constructor(options: CustomAccountManagerOptions);
+    initialize(): Promise<void>;
+    isInitialized(): boolean;
+    createAccount(input: CustomAccountInput): Promise<CreateAccountResult>;
+    deleteCustomAccount(code: string): Promise<DeleteAccountResult>;
+    updateLabel(code: string, newLabel: string): Promise<UpdateLabelResult>;
+    getOriginalLabel(code: string): string | null;
+    hasLabelOverride(code: string): boolean;
+    getByCode(code: string): Account | null;
+    has(code: string): boolean;
+    getAll(): Account[];
+    getCustomAccounts(): Account[];
+    getCustomAccountData(): CustomAccountData[];
+    getLabelOverrides(): LabelOverride[];
+    getChildren(code: string): Account[];
+    getByClass(classCode: string): Account[];
+    searchByName(query: string): Account[];
+    searchByPrefix(prefix: string): Account[];
+    save(): Promise<void>;
+    load(): Promise<void>;
+    clear(): Promise<void>;
+    getStats(): CustomAccountStats;
+    getTotalCount(): number;
+    getBaseRegistry(): AccountRegistry;
+    getStorage(): StorageAdapter;
+    private applyLabelOverride;
+    private ensureInitialized;
+    private getStorageKey;
+    private createAccountInstance;
+    private createAccountWithCustomLabel;
+}
+//# sourceMappingURL=CustomAccountManager.d.ts.map

package/dist/types/custom/CustomAccountValidator.d.ts

@@ -0,0 +1,23 @@
+import type { AccountRegistry } from '../core/AccountRegistry';
+import type { Account } from '../core/Account';
+import type { Result } from '../core/types';
+import type { CustomAccountInput, CustomAccountData } from './types';
+import { CannotModifyMainAccountError, CannotCreateMainAccountError, ParentAccountNotFoundError, AccountCodeConflictError, InvalidCustomCodeError } from './errors';
+export interface ValidatedAccountInput extends CustomAccountInput {
+    level: number;
+    classCode: string;
+}
+export declare class CustomAccountValidator {
+    private registry;
+    private customAccounts;
+    constructor(registry: AccountRegistry, customAccounts: Map<string, CustomAccountData>);
+    setCustomAccounts(customAccounts: Map<string, CustomAccountData>): void;
+    isMainAccount(code: string): boolean;
+    accountExists(code: string): boolean;
+    getAccount(code: string): Account | CustomAccountData | null;
+    validateCodeFormat(code: string, parentCode: string): Result<string, InvalidCustomCodeError>;
+    validateCreate(input: CustomAccountInput): Result<ValidatedAccountInput, CannotCreateMainAccountError | ParentAccountNotFoundError | AccountCodeConflictError | InvalidCustomCodeError>;
+    validateLabelUpdate(code: string): Result<Account | CustomAccountData, CannotModifyMainAccountError | InvalidCustomCodeError>;
+    validateDelete(code: string, customAccounts: Map<string, CustomAccountData>): Result<CustomAccountData, InvalidCustomCodeError>;
+}
+//# sourceMappingURL=CustomAccountValidator.d.ts.map

package/dist/types/custom/errors.d.ts

@@ -0,0 +1,37 @@
+import { OhadaKitError } from '../validation/errors';
+export declare abstract class CustomAccountError extends OhadaKitError {
+    abstract readonly code: string;
+}
+export declare class CannotModifyMainAccountError extends CustomAccountError {
+    readonly code = "CANNOT_MODIFY_MAIN_ACCOUNT";
+    readonly accountCode: string;
+    constructor(accountCode: string);
+}
+export declare class CannotCreateMainAccountError extends CustomAccountError {
+    readonly code = "CANNOT_CREATE_MAIN_ACCOUNT";
+    readonly accountCode: string;
+    constructor(accountCode: string);
+}
+export declare class ParentAccountNotFoundError extends CustomAccountError {
+    readonly code = "PARENT_ACCOUNT_NOT_FOUND";
+    readonly parentCode: string;
+    constructor(parentCode: string);
+}
+export declare class AccountCodeConflictError extends CustomAccountError {
+    readonly code = "ACCOUNT_CODE_CONFLICT";
+    readonly accountCode: string;
+    constructor(accountCode: string);
+}
+export declare class InvalidCustomCodeError extends CustomAccountError {
+    readonly code = "INVALID_CUSTOM_CODE";
+    readonly accountCode: string;
+    readonly reason: string;
+    constructor(accountCode: string, reason: string);
+}
+export declare class CustomStorageError extends CustomAccountError {
+    readonly code = "CUSTOM_STORAGE_ERROR";
+    readonly operation: string;
+    readonly originalError?: Error;
+    constructor(operation: string, message: string, originalError?: Error);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/types/custom/index.d.ts

@@ -0,0 +1,8 @@
+export { CustomAccountManager } from './CustomAccountManager';
+export { CustomAccountValidator } from './CustomAccountValidator';
+export type { ValidatedAccountInput } from './CustomAccountValidator';
+export { CustomAccountIndex } from './CustomAccountIndex';
+export type { CustomAccountInput, CustomAccountData, LabelOverride, CustomAccountStorage, CustomAccountManagerOptions, CreateAccountResult, UpdateLabelResult, DeleteAccountResult, CustomAccountStats, } from './types';
+export { STORAGE_KEYS, DEFAULT_STORAGE_PREFIX, STORAGE_VERSION, } from './types';
+export { CustomAccountError, CannotModifyMainAccountError, CannotCreateMainAccountError, ParentAccountNotFoundError, AccountCodeConflictError, InvalidCustomCodeError, CustomStorageError, } from './errors';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/custom/types.d.ts

@@ -0,0 +1,52 @@
+import type { StorageAdapter, Result } from '../core/types';
+import type { Account } from '../core/Account';
+export interface CustomAccountInput {
+    code: string;
+    name: string;
+    parentCode: string;
+}
+export interface CustomAccountData {
+    code: string;
+    name: string;
+    level: number;
+    classCode: string;
+    parentCode: string;
+    createdAt: string;
+    updatedAt: string;
+    isCustom: true;
+}
+export interface LabelOverride {
+    code: string;
+    originalName: string;
+    customName: string;
+    modifiedAt: string;
+}
+export interface CustomAccountStorage {
+    version: 1;
+    accounts: CustomAccountData[];
+    labelOverrides: LabelOverride[];
+    metadata: {
+        lastModified: string;
+        accountCount: number;
+        overrideCount: number;
+    };
+}
+export interface CustomAccountManagerOptions {
+    storage: StorageAdapter;
+    storagePrefix?: string;
+}
+export type CreateAccountResult = Result<Account>;
+export type UpdateLabelResult = Result<Account>;
+export type DeleteAccountResult = Result<void>;
+export interface CustomAccountStats {
+    customAccountCount: number;
+    labelOverrideCount: number;
+    byClass: Record<string, number>;
+    lastModified: string | null;
+}
+export declare const STORAGE_KEYS: {
+    readonly CUSTOM_ACCOUNTS: "custom:accounts";
+};
+export declare const DEFAULT_STORAGE_PREFIX = "ohadakit:";
+export declare const STORAGE_VERSION = 1;
+//# sourceMappingURL=types.d.ts.map

package/dist/types/data/ohada/accounts-flat.d.ts

@@ -0,0 +1,27 @@
+import { OhadaFlatAccount } from './types';
+export declare const flatAccounts: OhadaFlatAccount[];
+export declare function getAccountsByClass(classCode: string): OhadaFlatAccount[];
+export declare function getAccountsByLevel(level: number): OhadaFlatAccount[];
+export declare function getAccountByCode(code: string): OhadaFlatAccount | undefined;
+export declare function getChildAccounts(parentCode: string): OhadaFlatAccount[];
+export declare function searchFlatAccounts(query: string): OhadaFlatAccount[];
+export declare const flatAccountsStats: {
+    total: number;
+    byClass: {
+        class1: number;
+        class2: number;
+        class3: number;
+        class4: number;
+        class5: number;
+        class6: number;
+        class7: number;
+        class8: number;
+        class9: number;
+    };
+    byLevel: {
+        level2: number;
+        level3: number;
+        level4: number;
+    };
+};
+//# sourceMappingURL=accounts-flat.d.ts.map

package/dist/types/data/ohada/class-1-ressources.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class1: OhadaClass;
+//# sourceMappingURL=class-1-ressources.d.ts.map

package/dist/types/data/ohada/class-2-immobilisations.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class2: OhadaClass;
+//# sourceMappingURL=class-2-immobilisations.d.ts.map

package/dist/types/data/ohada/class-3-stocks.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class3: OhadaClass;
+//# sourceMappingURL=class-3-stocks.d.ts.map

package/dist/types/data/ohada/class-4-tiers.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class4: OhadaClass;
+//# sourceMappingURL=class-4-tiers.d.ts.map

package/dist/types/data/ohada/class-5-tresorerie.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class5: OhadaClass;
+//# sourceMappingURL=class-5-tresorerie.d.ts.map

package/dist/types/data/ohada/class-6-charges.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class6: OhadaClass;
+//# sourceMappingURL=class-6-charges.d.ts.map

package/dist/types/data/ohada/class-7-produits.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class7: OhadaClass;
+//# sourceMappingURL=class-7-produits.d.ts.map

package/dist/types/data/ohada/class-8-hao.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class8: OhadaClass;
+//# sourceMappingURL=class-8-hao.d.ts.map

package/dist/types/data/ohada/class-9-engagements.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClass } from './types';
+export declare const class9: OhadaClass;
+//# sourceMappingURL=class-9-engagements.d.ts.map

package/dist/types/data/ohada/classes.d.ts

@@ -0,0 +1,3 @@
+import { OhadaClassReference } from './types';
+export declare const ohadaClasses: OhadaClassReference[];
+//# sourceMappingURL=classes.d.ts.map

package/dist/types/data/ohada/index.d.ts

@@ -0,0 +1,26 @@
+import { OhadaChartIndex, OhadaClass, OhadaAccount } from './types';
+import { ohadaClasses } from './classes';
+import { class1 } from './class-1-ressources';
+import { class2 } from './class-2-immobilisations';
+import { class3 } from './class-3-stocks';
+import { class4 } from './class-4-tiers';
+import { class5 } from './class-5-tresorerie';
+import { class6 } from './class-6-charges';
+import { class7 } from './class-7-produits';
+import { class8 } from './class-8-hao';
+import { class9 } from './class-9-engagements';
+export declare const ohadaChartIndex: OhadaChartIndex;
+export declare const allClasses: OhadaClass[];
+export declare function getClass(classCode: string): OhadaClass | undefined;
+export declare function findAccount(accountCode: string): OhadaAccount | undefined;
+export declare function getAccountsByLevel(level: number): OhadaAccount[];
+export declare function searchAccounts(query: string): OhadaAccount[];
+export declare function getAccountWithPath(accountCode: string): {
+    account: OhadaAccount;
+    path: string[];
+} | undefined;
+export declare function getTotalAccountCount(): number;
+export * from './types';
+export { class1, class2, class3, class4, class5, class6, class7, class8, class9 };
+export { ohadaClasses };
+//# sourceMappingURL=index.d.ts.map