avantgate 1.0.0 → 1.1.0

package/dist/chunk-CO26LNFD.mjs

@@ -0,0 +1,521 @@
+// src/finance/strategies/french-pcg.strategy.ts
+var FrenchPCGStrategy = class {
+  jurisdictionCode = "FR";
+  standard = "PCG";
+  defaultCurrency = "EUR";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^\(\s*(.+?)\s*\)$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK](?:€|eur)?\b/i.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK](?:€|eur)?\b/gi, "").trim();
+    } else if (/[mM](?:€|eur)?\b/i.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM](?:€|eur)?\b/gi, "").trim();
+    }
+    str = str.replace(/[€$£]/g, "").replace(/\s+/g, "").replace(/\u00A0/g, "").trim();
+    str = str.replace(",", ".");
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalValue = parsed * multiplier;
+    return isNegative ? -Math.abs(finalValue) : finalValue;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)\(\s*([0-9][0-9\s.,]*(?:k€|k|keur|m€|m|meur|€)?)\s*\)/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*\(\s*([0-9][0-9\s.,]*(?:k€|k|keur|m€|m|meur|€)?)\s*\)\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?[0-9][0-9\s.,]*(?:k€|k|keur|m€|m|meur|€))\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?(?:[0-9]{1,3}(?:\s+[0-9]{3})+(?:,[0-9]+)?|[0-9]+,[0-9]+))\s*"/g,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(text) {
+    const lower = text.toLowerCase();
+    const frPatterns = [
+      /\bcerfa\b/i,
+      /\bliasse\s+fiscale\b/i,
+      /\bbilan\s+(actif|passif)\b/i,
+      /\bcompte\s+de\s+r[ée]sultat\b/i,
+      /\bplan\s+comptable\s+g[ée]n[ée]ral\b/i,
+      /\bpcg\b/i,
+      /\bsiren\b/i,
+      /\bsiret\b/i,
+      /\b[0-9\s.,]+(?:k€|m€)\b/i,
+      /\beur\b/i,
+      /€/
+    ];
+    return frPatterns.some((pattern) => pattern.test(lower));
+  }
+};
+
+// src/finance/strategies/us-gaap.strategy.ts
+var UsGAAPStrategy = class {
+  jurisdictionCode = "US";
+  standard = "US_GAAP";
+  defaultCurrency = "USD";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^[(\[]\s*(.+?)\s*[)\]]$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK]\b/.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK]\b/g, "").trim();
+    } else if (/[mM]\b/.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM]\b/g, "").trim();
+    } else if (/[bB]\b/.test(str)) {
+      multiplier = 1e9;
+      str = str.replace(/[bB]\b/g, "").trim();
+    }
+    str = str.replace(/[$]/g, "").replace(/\busd\b/gi, "").replace(/,/g, "").replace(/\s+/g, "").trim();
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalVal = parsed * multiplier;
+    return isNegative ? -Math.abs(finalVal) : finalVal;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)[(\[]\s*([0-9][0-9,.]*(?:k|m|b|\$)?)\s*[)\]]/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*[(\[]\s*([0-9][0-9,.]*(?:k|m|b|\$)?)\s*[)\]]\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?\$?\s*[0-9][0-9,.]*\s*(?:k|m|b|\$)?)\s*"/gi,
+      (_, prefix, amountStr) => {
+        if (!amountStr.includes("$") && !/[kmb]/i.test(amountStr)) {
+          return `${prefix}"${amountStr}"`;
+        }
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(text) {
+    const lower = text.toLowerCase();
+    const usPatterns = [
+      /\b10-[kq]\b/i,
+      /\bsec\s+filing\b/i,
+      /\bus[\s_-]?gaap\b/i,
+      /\bbalance\s+sheet\b/i,
+      /\bincome\s+statement\b/i,
+      /\bstatement\s+of\s+cash\s+flows\b/i,
+      /\$|usd/i
+    ];
+    return usPatterns.some((pattern) => pattern.test(lower));
+  }
+};
+
+// src/finance/strategies/uk-ifrs.strategy.ts
+var UkIFRSStrategy = class {
+  jurisdictionCode = "UK";
+  standard = "IFRS";
+  defaultCurrency = "GBP";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^\(\s*(.+?)\s*\)$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK]\b/.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK]\b/g, "").trim();
+    } else if (/[mM]\b/.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM]\b/g, "").trim();
+    }
+    str = str.replace(/[£]/g, "").replace(/\bgbp\b/gi, "").replace(/,/g, "").replace(/\s+/g, "").trim();
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalVal = parsed * multiplier;
+    return isNegative ? -Math.abs(finalVal) : finalVal;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)\(\s*([0-9][0-9,.]*(?:k|m|£)?)\s*\)/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*\(\s*([0-9][0-9,.]*(?:k|m|£)?)\s*\)\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?£\s*[0-9][0-9,.]*\s*(?:k|m)?)\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(text) {
+    const lower = text.toLowerCase();
+    const ukPatterns = [
+      /\bcompanies\s+house\b/i,
+      /\bfrs\s*102\b/i,
+      /\bhmrc\b/i,
+      /\bprofit\s+and\s+loss\b/i,
+      /£|\bgbp\b/i
+    ];
+    return ukPatterns.some((pattern) => pattern.test(lower));
+  }
+};
+
+// src/finance/strategies/swiss-co.strategy.ts
+var SwissCOStrategy = class {
+  jurisdictionCode = "CH";
+  standard = "SWISS_CO";
+  defaultCurrency = "CHF";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^\(\s*(.+?)\s*\)$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK]\b/.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK]\b/g, "").trim();
+    } else if (/[mM]\b/.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM]\b/g, "").trim();
+    }
+    str = str.replace(/\bchf\b/gi, "").replace(/['’]/g, "").replace(/\s+/g, "").trim();
+    str = str.replace(",", ".");
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalVal = parsed * multiplier;
+    return isNegative ? -Math.abs(finalVal) : finalVal;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)\(\s*([0-9][0-9'’.,\s]*(?:k|m|chf)?)\s*\)/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*\(\s*([0-9][0-9'’.,\s]*(?:k|m|chf)?)\s*\)\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*([+-]?[0-9][0-9'’.,\s]*(?:k|m|chf))\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(amountStr);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(text) {
+    const lower = text.toLowerCase();
+    const chPatterns = [
+      /\bcode\s+des\s+obligations\b/i,
+      /\bart\.?\s*725\b/i,
+      /\bche-[0-9]{3}\.[0-9]{3}\.[0-9]{3}\b/i,
+      /\bchf\b/i,
+      /\b[0-9]{1,3}(?:'[0-9]{3})+\b/
+    ];
+    return chPatterns.some((pattern) => pattern.test(lower));
+  }
+};
+
+// src/finance/strategies/international.strategy.ts
+var InternationalAccountingStrategy = class {
+  jurisdictionCode = "INTERNATIONAL";
+  standard = "OTHER";
+  defaultCurrency = "EUR";
+  cleanNumber(value) {
+    if (typeof value === "number") {
+      return Number.isFinite(value) ? value : 0;
+    }
+    if (!value || typeof value !== "string") {
+      return 0;
+    }
+    let str = value.trim();
+    let isNegative = false;
+    const parenMatch = str.match(/^[(\[]\s*(.+?)\s*[)\]]$/);
+    if (parenMatch) {
+      isNegative = true;
+      str = parenMatch[1];
+    } else if (str.startsWith("-")) {
+      isNegative = true;
+      str = str.substring(1).trim();
+    }
+    let multiplier = 1;
+    if (/[kK]\b/.test(str)) {
+      multiplier = 1e3;
+      str = str.replace(/[kK]\b/g, "").trim();
+    } else if (/[mM]\b/.test(str)) {
+      multiplier = 1e6;
+      str = str.replace(/[mM]\b/g, "").trim();
+    }
+    str = str.replace(/[€$£]/g, "").replace(/\b(?:eur|usd|gbp|chf)\b/gi, "").trim();
+    if (str.includes(",") && str.includes(".")) {
+      if (str.lastIndexOf(",") > str.lastIndexOf(".")) {
+        str = str.replace(/\./g, "").replace(",", ".");
+      } else {
+        str = str.replace(/,/g, "");
+      }
+    } else if (str.includes(",")) {
+      if (/,\d{1,2}$/.test(str)) {
+        str = str.replace(",", ".");
+      } else {
+        str = str.replace(",", "");
+      }
+    }
+    str = str.replace(/\s+/g, "");
+    const parsed = parseFloat(str);
+    if (isNaN(parsed)) {
+      return 0;
+    }
+    const finalVal = parsed * multiplier;
+    return isNegative ? -Math.abs(finalVal) : finalVal;
+  }
+  cleanJSON(rawText) {
+    let result = rawText;
+    result = result.replace(
+      /(:\s*)[(\[]\s*([0-9][0-9,.\s]*(?:k|m|€|\$|£)?)\s*[)\]]/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    result = result.replace(
+      /(:\s*)"\s*[(\[]\s*([0-9][0-9,.\s]*(?:k|m|€|\$|£)?)\s*[)\]]\s*"/gi,
+      (_, prefix, amountStr) => {
+        const num = this.cleanNumber(`(${amountStr})`);
+        return `${prefix}${num}`;
+      }
+    );
+    return result;
+  }
+  detect(_text) {
+    return true;
+  }
+};
+
+// src/finance/factory.ts
+var AccountingFactory = class {
+  static strategies = /* @__PURE__ */ new Map();
+  static detectionOrder = [];
+  static {
+    this.initDefaults();
+  }
+  static initDefaults() {
+    const fr = new FrenchPCGStrategy();
+    const us = new UsGAAPStrategy();
+    const uk = new UkIFRSStrategy();
+    const ch = new SwissCOStrategy();
+    const intl = new InternationalAccountingStrategy();
+    this.registerStrategy(ch);
+    this.registerStrategy(uk);
+    this.registerStrategy(us);
+    this.registerStrategy(fr);
+    this.registerStrategy(intl);
+  }
+  static registerStrategy(strategy) {
+    this.strategies.set(strategy.jurisdictionCode, strategy);
+    this.detectionOrder = [
+      strategy,
+      ...this.detectionOrder.filter((s) => s.jurisdictionCode !== strategy.jurisdictionCode)
+    ];
+  }
+  static getStrategy(code) {
+    if (!code) {
+      return this.strategies.get("FR") || new FrenchPCGStrategy();
+    }
+    const strategy = this.strategies.get(code);
+    if (!strategy) {
+      return this.strategies.get("FR") || new FrenchPCGStrategy();
+    }
+    return strategy;
+  }
+  static detectStrategy(documentText) {
+    for (const strategy of this.detectionOrder) {
+      if (strategy.jurisdictionCode !== "INTERNATIONAL" && strategy.detect(documentText)) {
+        return strategy;
+      }
+    }
+    return this.getStrategy("FR");
+  }
+  static resetDefaults() {
+    this.strategies.clear();
+    this.detectionOrder = [];
+    this.initDefaults();
+  }
+};
+
+// src/response-validator.ts
+function extractAndCleanJSON(rawText) {
+  let cleaned = rawText.trim();
+  cleaned = cleaned.replace(/<think>[\s\S]*?<\/think>/gi, "").trim();
+  const codeBlockMatch = cleaned.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
+  if (codeBlockMatch && codeBlockMatch[1]) {
+    cleaned = codeBlockMatch[1].trim();
+  }
+  const firstBrace = cleaned.indexOf("{");
+  const firstBracket = cleaned.indexOf("[");
+  let startIndex = -1;
+  if (firstBrace !== -1 && firstBracket !== -1) {
+    startIndex = Math.min(firstBrace, firstBracket);
+  } else if (firstBrace !== -1) {
+    startIndex = firstBrace;
+  } else if (firstBracket !== -1) {
+    startIndex = firstBracket;
+  }
+  const lastBrace = cleaned.lastIndexOf("}");
+  const lastBracket = cleaned.lastIndexOf("]");
+  const endIndex = Math.max(lastBrace, lastBracket);
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    cleaned = cleaned.slice(startIndex, endIndex + 1);
+  }
+  return cleaned;
+}
+function validateWithZod(rawText, schema, options) {
+  let jsonString = extractAndCleanJSON(rawText);
+  if (options?.normalizer) {
+    jsonString = options.normalizer(jsonString);
+  } else if (options?.financialNormalizer) {
+    jsonString = cleanFinancialJSON(jsonString, { jurisdiction: options.jurisdiction });
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonString);
+  } catch (_error) {
+    const sanitized = jsonString.replace(/,\s*([}\]])/g, "$1").replace(/'/g, '"');
+    parsed = JSON.parse(sanitized);
+  }
+  return schema.parse(parsed);
+}
+
+// src/finance/normalizer.ts
+function cleanFinancialJSON(rawText, options) {
+  if (!rawText) {
+    return "";
+  }
+  const jsonBlock = extractAndCleanJSON(rawText);
+  const strategy = options?.jurisdiction ? AccountingFactory.getStrategy(options.jurisdiction) : options?.autoDetect !== false ? AccountingFactory.detectStrategy(rawText) : AccountingFactory.getStrategy("FR");
+  return strategy.cleanJSON(jsonBlock);
+}
+function withFinancialNormalizer(options) {
+  return (rawText) => cleanFinancialJSON(rawText, options);
+}
+
+export {
+  FrenchPCGStrategy,
+  UsGAAPStrategy,
+  UkIFRSStrategy,
+  SwissCOStrategy,
+  InternationalAccountingStrategy,
+  AccountingFactory,
+  cleanFinancialJSON,
+  withFinancialNormalizer,
+  extractAndCleanJSON,
+  validateWithZod
+};

package/dist/finance/index.d.mts

@@ -0,0 +1,76 @@
+import { I as IAccountingStrategy, F as FinancialJurisdictionCode, A as AccountingStandard, a as FinancialCurrency } from '../strategy.interface-CB4_ZAuk.mjs';
+
+declare class AccountingFactory {
+    private static strategies;
+    private static detectionOrder;
+    private static initDefaults;
+    static registerStrategy(strategy: IAccountingStrategy): void;
+    static getStrategy(code?: FinancialJurisdictionCode): IAccountingStrategy;
+    static detectStrategy(documentText: string): IAccountingStrategy;
+    static resetDefaults(): void;
+}
+
+interface FinancialNormalizerOptions {
+    jurisdiction?: FinancialJurisdictionCode;
+    autoDetect?: boolean;
+}
+/**
+ * Assainit et répare une chaîne JSON contenant des données financières :
+ * - Notation comptable négative entre parenthèses : (150 000) -> -150000
+ * - Espaces et virgules décimales : "1 850 000,50 €" -> 1850000.50
+ * - Abréviations de grandeurs : "1 850 k€" -> 1850000, "2.4 M€" -> 2400000
+ * - Suppression des symboles de devises dans les positions numériques
+ * - Préservation stricte des chaînes descriptives normales contenant des parenthèses
+ */
+declare function cleanFinancialJSON(rawText: string, options?: FinancialNormalizerOptions): string;
+/**
+ * Crée une fonction de transformation financière réutilisable.
+ */
+declare function withFinancialNormalizer(options?: FinancialNormalizerOptions): (rawText: string) => string;
+
+declare class FrenchPCGStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(text: string): boolean;
+}
+
+declare class UsGAAPStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(text: string): boolean;
+}
+
+declare class UkIFRSStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(text: string): boolean;
+}
+
+declare class SwissCOStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(text: string): boolean;
+}
+
+declare class InternationalAccountingStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(_text: string): boolean;
+}
+
+export { AccountingFactory, AccountingStandard, FinancialCurrency, FinancialJurisdictionCode, type FinancialNormalizerOptions, FrenchPCGStrategy, IAccountingStrategy, InternationalAccountingStrategy, SwissCOStrategy, UkIFRSStrategy, UsGAAPStrategy, cleanFinancialJSON, withFinancialNormalizer };

package/dist/finance/index.d.ts

@@ -0,0 +1,76 @@
+import { I as IAccountingStrategy, F as FinancialJurisdictionCode, A as AccountingStandard, a as FinancialCurrency } from '../strategy.interface-CB4_ZAuk.js';
+
+declare class AccountingFactory {
+    private static strategies;
+    private static detectionOrder;
+    private static initDefaults;
+    static registerStrategy(strategy: IAccountingStrategy): void;
+    static getStrategy(code?: FinancialJurisdictionCode): IAccountingStrategy;
+    static detectStrategy(documentText: string): IAccountingStrategy;
+    static resetDefaults(): void;
+}
+
+interface FinancialNormalizerOptions {
+    jurisdiction?: FinancialJurisdictionCode;
+    autoDetect?: boolean;
+}
+/**
+ * Assainit et répare une chaîne JSON contenant des données financières :
+ * - Notation comptable négative entre parenthèses : (150 000) -> -150000
+ * - Espaces et virgules décimales : "1 850 000,50 €" -> 1850000.50
+ * - Abréviations de grandeurs : "1 850 k€" -> 1850000, "2.4 M€" -> 2400000
+ * - Suppression des symboles de devises dans les positions numériques
+ * - Préservation stricte des chaînes descriptives normales contenant des parenthèses
+ */
+declare function cleanFinancialJSON(rawText: string, options?: FinancialNormalizerOptions): string;
+/**
+ * Crée une fonction de transformation financière réutilisable.
+ */
+declare function withFinancialNormalizer(options?: FinancialNormalizerOptions): (rawText: string) => string;
+
+declare class FrenchPCGStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(text: string): boolean;
+}
+
+declare class UsGAAPStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(text: string): boolean;
+}
+
+declare class UkIFRSStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(text: string): boolean;
+}
+
+declare class SwissCOStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(text: string): boolean;
+}
+
+declare class InternationalAccountingStrategy implements IAccountingStrategy {
+    readonly jurisdictionCode: FinancialJurisdictionCode;
+    readonly standard: AccountingStandard;
+    readonly defaultCurrency: FinancialCurrency;
+    cleanNumber(value: string | number): number;
+    cleanJSON(rawText: string): string;
+    detect(_text: string): boolean;
+}
+
+export { AccountingFactory, AccountingStandard, FinancialCurrency, FinancialJurisdictionCode, type FinancialNormalizerOptions, FrenchPCGStrategy, IAccountingStrategy, InternationalAccountingStrategy, SwissCOStrategy, UkIFRSStrategy, UsGAAPStrategy, cleanFinancialJSON, withFinancialNormalizer };