@taxora/sdk 1.0.7 → 1.2.0

package/dist/index.cjs

@@ -26,15 +26,38 @@ __export(index_exports, {
   AuthenticationException: () => AuthenticationException,
   CompanyAddress: () => CompanyAddress,
   CompanyEndpoint: () => CompanyEndpoint,
+  ComplianceEnrollment: () => ComplianceEnrollment,
+  ComplianceEnrollmentPage: () => ComplianceEnrollmentPage,
+  ComplianceEnrollmentStatus: () => ComplianceEnrollmentStatus,
+  ComplianceTaxReport: () => ComplianceTaxReport,
+  ComplianceTaxReportPage: () => ComplianceTaxReportPage,
+  ComplianceTaxReportState: () => ComplianceTaxReportState,
+  ComplianceTransaction: () => ComplianceTransaction,
+  ComplianceTransactionPage: () => ComplianceTransactionPage,
+  ComplianceTransactionState: () => ComplianceTransactionState,
+  ComplianceTransactionType: () => ComplianceTransactionType,
+  EReportingEndpoint: () => EReportingEndpoint,
   Environment: () => Environment,
   FetchHttpClient: () => FetchHttpClient,
   HttpException: () => HttpException,
+  ImportResult: () => ImportResult,
   InMemoryTokenStorage: () => InMemoryTokenStorage,
   Language: () => Language,
   LoginIdentifier: () => LoginIdentifier,
   ProviderDocument: () => ProviderDocument,
   ProviderDocumentLine: () => ProviderDocumentLine,
+  RetryPolicy: () => RetryPolicy,
+  RevenueStatistics: () => RevenueStatistics,
   ScoreBreakdown: () => ScoreBreakdown,
+  SireneLookupResult: () => SireneLookupResult,
+  SmartEnrichmentEndpoint: () => SmartEnrichmentEndpoint,
+  SmartEnrichmentHistoryPage: () => SmartEnrichmentHistoryPage,
+  SmartEnrichmentHistoryRow: () => SmartEnrichmentHistoryRow,
+  SmartEnrichmentJob: () => SmartEnrichmentJob,
+  SmartEnrichmentMode: () => SmartEnrichmentMode,
+  SmartEnrichmentResource: () => SmartEnrichmentResource,
+  SmartEnrichmentStatistics: () => SmartEnrichmentStatistics,
+  SmartEnrichmentStatus: () => SmartEnrichmentStatus,
   TaxoraClient: () => TaxoraClient,
   TaxoraClientFactory: () => TaxoraClientFactory,
   TaxoraException: () => TaxoraException,
@@ -43,12 +66,26 @@ __export(index_exports, {
   VatCertificateExport: () => VatCertificateExport,
   VatCollection: () => VatCollection,
   VatEndpoint: () => VatEndpoint,
+  VatRates: () => VatRates,
   VatResource: () => VatResource,
   VatState: () => VatState,
   VatValidationAddressInput: () => VatValidationAddressInput,
+  describeApiError: () => describeApiError,
+  describeComplianceEnrollmentStatus: () => describeComplianceEnrollmentStatus,
+  describeComplianceTaxReportState: () => describeComplianceTaxReportState,
+  describeComplianceTransactionState: () => describeComplianceTransactionState,
+  describeComplianceTransactionType: () => describeComplianceTransactionType,
+  describeSmartEnrichmentMode: () => describeSmartEnrichmentMode,
+  describeSmartEnrichmentStatus: () => describeSmartEnrichmentStatus,
   describeVatState: () => describeVatState,
   getBaseUrl: () => getBaseUrl,
-  getFailedVatStates: () => getFailedVatStates
+  getFailedVatStates: () => getFailedVatStates,
+  toComplianceEnrollmentStatus: () => toComplianceEnrollmentStatus,
+  toComplianceTaxReportState: () => toComplianceTaxReportState,
+  toComplianceTransactionState: () => toComplianceTransactionState,
+  toComplianceTransactionType: () => toComplianceTransactionType,
+  toSmartEnrichmentMode: () => toSmartEnrichmentMode,
+  toSmartEnrichmentStatus: () => toSmartEnrichmentStatus
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -114,37 +151,299 @@ var AuthenticationException = class extends TaxoraException {
   }
 };
 
+// src/exceptions/apiErrorMessage.ts
+var MAX_LENGTH = 500;
+var MAX_PLAIN_LENGTH = 200;
+var REASON_PHRASES = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  408: "Request Timeout",
+  409: "Conflict",
+  413: "Payload Too Large",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout"
+};
+function describeApiError(body, statusCode) {
+  return jsonErrorMessage(body) ?? plainErrorMessage(body) ?? statusErrorMessage(statusCode);
+}
+function detailApiError(body, statusCode) {
+  return jsonErrorMessage(body) ?? plainErrorMessage(body) ?? statusPhrase(statusCode);
+}
+function jsonErrorMessage(body) {
+  if (body === null || body === void 0 || body.trim() === "") return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null) return null;
+  const payload = parsed;
+  for (const key of ["message", "error"]) {
+    const value = payload[key];
+    if (typeof value === "string") {
+      const message = sanitize(value);
+      if (message !== null) return message;
+    }
+  }
+  const errors = payload["errors"];
+  if (typeof errors === "object" && errors !== null) {
+    return fromErrorBag(errors);
+  }
+  return null;
+}
+function statusErrorMessage(statusCode) {
+  return `Taxora API request failed (${statusPhrase(statusCode)}).`;
+}
+function statusPhrase(statusCode) {
+  const phrase = REASON_PHRASES[statusCode];
+  return `HTTP ${statusCode}${phrase ? ` ${phrase}` : ""}`;
+}
+function plainErrorMessage(body) {
+  if (body === null || body === void 0) return null;
+  const value = body.replace(/\s+/g, " ").trim();
+  if (value === "" || value.length > MAX_PLAIN_LENGTH) return null;
+  if (value.includes("<") || value.includes("{")) return null;
+  return value;
+}
+function fromErrorBag(errors) {
+  for (const [field, messages] of Object.entries(errors)) {
+    for (const message of Array.isArray(messages) ? messages : [messages]) {
+      if (typeof message !== "string") continue;
+      const sanitized = sanitize(message);
+      if (sanitized === null) continue;
+      return field !== "" ? `${field}: ${sanitized}` : sanitized;
+    }
+  }
+  return null;
+}
+function sanitize(value) {
+  const collapsed = value.replace(/\s+/g, " ").trim();
+  if (collapsed === "") return null;
+  if (/<!doctype\s+html|<html[\s>]/i.test(collapsed)) return null;
+  return collapsed.length > MAX_LENGTH ? `${collapsed.slice(0, MAX_LENGTH - 1)}\u2026` : collapsed;
+}
+
 // src/exceptions/HttpException.ts
-var HttpException = class extends TaxoraException {
+var HttpException = class _HttpException extends TaxoraException {
   statusCode;
   responseBody;
-  constructor(message, statusCode, responseBody, context = {}) {
+  /** Raw `Retry-After` header of the failed response, when it carried one. */
+  retryAfter;
+  constructor(message, statusCode, responseBody, context = {}, retryAfter = null) {
     super(message, context);
     this.name = "HttpException";
     this.statusCode = statusCode;
     this.responseBody = responseBody;
+    this.retryAfter = retryAfter;
     Object.setPrototypeOf(this, new.target.prototype);
   }
+  /**
+   * The final failure after the SDK retried a transient gateway error, e.g.
+   * "Taxora VAT validation failed after 3 attempts (HTTP 504 Gateway Timeout)."
+   */
+  static afterAttempts(operation, attempts, last) {
+    const detail = detailApiError(last.getResponseBody(), last.getStatusCode());
+    return new _HttpException(
+      `Taxora ${operation} failed after ${attempts} attempts (${detail}).`,
+      last.getStatusCode(),
+      last.getResponseBody(),
+      { ...last.context, attempts, cause: last },
+      last.getRetryAfter()
+    );
+  }
   getStatusCode() {
     return this.statusCode;
   }
   getResponseBody() {
     return this.responseBody;
   }
+  getRetryAfter() {
+    return this.retryAfter;
+  }
 };
 
+// src/http/RetryPolicy.ts
+var DEFAULT_RETRYABLE_STATUS_CODES = [502, 503, 504];
+var RETRY_AFTER_ONLY_STATUS_CODES = [429];
+var NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ECONNABORTED",
+  "EPIPE",
+  "ETIMEDOUT",
+  "EAI_AGAIN",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "ENETDOWN",
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_HEADERS_TIMEOUT",
+  "UND_ERR_BODY_TIMEOUT",
+  "UND_ERR_SOCKET"
+]);
+var RetryPolicy = class _RetryPolicy {
+  maxAttempts;
+  initialDelayMs;
+  backoffMultiplier;
+  maxDelayMs;
+  retryableStatusCodes;
+  respectRetryAfter;
+  maxRetryAfterMs;
+  retryOnNetworkErrors;
+  sleeper;
+  constructor(options = {}) {
+    this.maxAttempts = options.maxAttempts ?? 3;
+    this.initialDelayMs = options.initialDelayMs ?? 500;
+    this.backoffMultiplier = options.backoffMultiplier ?? 2;
+    this.maxDelayMs = options.maxDelayMs ?? 5e3;
+    this.retryableStatusCodes = options.retryableStatusCodes ?? DEFAULT_RETRYABLE_STATUS_CODES;
+    this.respectRetryAfter = options.respectRetryAfter ?? true;
+    this.maxRetryAfterMs = options.maxRetryAfterMs ?? 1e4;
+    this.retryOnNetworkErrors = options.retryOnNetworkErrors ?? true;
+    this.sleeper = options.sleeper;
+    if (this.maxAttempts < 1) throw new Error("maxAttempts must be at least 1.");
+    if (this.initialDelayMs < 0 || this.maxDelayMs < 0) throw new Error("Delays must not be negative.");
+    if (this.backoffMultiplier < 1) throw new Error("backoffMultiplier must be at least 1.");
+  }
+  /** No retrying at all — every failure is surfaced on the first attempt. */
+  static disabled() {
+    return new _RetryPolicy({ maxAttempts: 1 });
+  }
+  /** Retry immediately, without waiting (mainly useful in tests). */
+  static withoutDelay(maxAttempts = 3) {
+    return new _RetryPolicy({ maxAttempts, initialDelayMs: 0, maxDelayMs: 0 });
+  }
+  isRetryable(statusCode, retryAfterHeader) {
+    const retryAfterMs = this.retryAfterMs(retryAfterHeader);
+    if (retryAfterMs !== null && retryAfterMs > this.maxRetryAfterMs) return false;
+    if (this.retryableStatusCodes.includes(statusCode)) return true;
+    return retryAfterMs !== null && RETRY_AFTER_ONLY_STATUS_CODES.includes(statusCode);
+  }
+  /** @param attempt Number of attempts made so far (1 = the first one just failed). */
+  shouldRetry(statusCode, attempt, retryAfterHeader) {
+    return attempt < this.maxAttempts && this.isRetryable(statusCode, retryAfterHeader);
+  }
+  /**
+   * A connection-level failure: the request never got an answer, so repeating it
+   * is as safe as repeating a gateway timeout.
+   */
+  isRetryableError(error) {
+    if (!this.retryOnNetworkErrors || !(error instanceof Error)) return false;
+    if (error.name === "AbortError" || error.name === "TimeoutError") return true;
+    const code = error.code ?? error.cause?.code;
+    if (typeof code === "string" && NETWORK_ERROR_CODES.has(code)) return true;
+    return error instanceof TypeError && /fetch failed|network|failed to fetch/i.test(error.message);
+  }
+  shouldRetryError(error, attempt) {
+    return attempt < this.maxAttempts && this.isRetryableError(error);
+  }
+  /**
+   * The wait the API asked for, in milliseconds — seconds or HTTP-date form — or
+   * null when there is none, it cannot be parsed, or the header is ignored.
+   */
+  retryAfterMs(header, now = /* @__PURE__ */ new Date()) {
+    if (!this.respectRetryAfter || header === null || header === void 0) return null;
+    const value = header.trim();
+    if (value === "") return null;
+    if (/^\d+$/.test(value)) return Number(value) * 1e3;
+    const date = Date.parse(value);
+    if (Number.isNaN(date)) return null;
+    return Math.max(0, date - now.getTime());
+  }
+  /** The wait before the next attempt: what the API asked for, else exponential backoff. */
+  delayMsForAttempt(attempt, retryAfterHeader) {
+    const retryAfterMs = this.retryAfterMs(retryAfterHeader);
+    if (retryAfterMs !== null) return Math.min(retryAfterMs, this.maxRetryAfterMs);
+    if (this.initialDelayMs === 0) return 0;
+    const delay = Math.round(this.initialDelayMs * this.backoffMultiplier ** Math.max(0, attempt - 1));
+    return Math.max(0, Math.min(delay, this.maxDelayMs));
+  }
+  async sleepBeforeRetry(attempt, retryAfterHeader) {
+    const delayMs = this.delayMsForAttempt(attempt, retryAfterHeader);
+    if (delayMs <= 0) return;
+    if (this.sleeper) {
+      await this.sleeper(delayMs);
+      return;
+    }
+    await new Promise((resolve) => setTimeout(resolve, delayMs));
+  }
+};
+
+// src/http/withRetries.ts
+async function withRetries(policy, operation, request) {
+  let attempt = 1;
+  for (; ; ) {
+    try {
+      return await request();
+    } catch (error) {
+      if (!(error instanceof HttpException)) {
+        if (!policy.shouldRetryError(error, attempt)) throw error;
+        await policy.sleepBeforeRetry(attempt);
+        attempt++;
+        continue;
+      }
+      const retryAfter = error.getRetryAfter();
+      if (!policy.shouldRetry(error.getStatusCode(), attempt, retryAfter)) {
+        throw attempt > 1 && policy.isRetryable(error.getStatusCode(), retryAfter) ? HttpException.afterAttempts(operation, attempt, error) : error;
+      }
+      await policy.sleepBeforeRetry(attempt, retryAfter);
+      attempt++;
+    }
+  }
+}
+async function withResponseRetries(policy, operation, send) {
+  let attempt = 1;
+  for (; ; ) {
+    let response;
+    try {
+      response = await send();
+    } catch (error) {
+      if (!policy.shouldRetryError(error, attempt)) throw error;
+      await policy.sleepBeforeRetry(attempt);
+      attempt++;
+      continue;
+    }
+    const retryAfter = response.headers.get("retry-after");
+    if (!policy.shouldRetry(response.status, attempt, retryAfter)) {
+      if (attempt > 1 && policy.isRetryable(response.status, retryAfter)) {
+        const body = await response.text();
+        const last = new HttpException(
+          describeApiError(body, response.status),
+          response.status,
+          body,
+          {},
+          retryAfter
+        );
+        throw HttpException.afterAttempts(operation, attempt, last);
+      }
+      return response;
+    }
+    await policy.sleepBeforeRetry(attempt, retryAfter);
+    attempt++;
+  }
+}
+
 // src/endpoints/AuthEndpoint.ts
 var AuthEndpoint = class {
-  constructor(baseUrl, apiKey, tokenStorage, httpClient) {
+  constructor(baseUrl, apiKey, tokenStorage, httpClient, retryPolicy = new RetryPolicy()) {
     this.baseUrl = baseUrl;
     this.apiKey = apiKey;
     this.tokenStorage = tokenStorage;
     this.httpClient = httpClient;
+    this.retryPolicy = retryPolicy;
   }
   baseUrl;
   apiKey;
   tokenStorage;
   httpClient;
+  retryPolicy;
   async login(identifier, password, device, loginIdentifier = LoginIdentifier.EMAIL) {
     const deviceName = device ?? (0, import_os.hostname)();
     const body = {
@@ -157,62 +456,1296 @@ var AuthEndpoint = class {
     } else {
       body["email"] = identifier;
     }
-    const response = await this.httpClient.request("POST", `${this.baseUrl}/auth/login`, {
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": this.apiKey
-      },
-      body: JSON.stringify(body)
+    const data = await withRetries(this.retryPolicy, "login", async () => {
+      const response = await this.httpClient.request("POST", `${this.baseUrl}/auth/login`, {
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey
+        },
+        body: JSON.stringify(body)
+      });
+      const responseText = await response.text();
+      if (response.status === 401) {
+        throw new AuthenticationException("Authentication failed: invalid credentials", {
+          status: 401,
+          body: responseText
+        });
+      }
+      if (!response.ok) {
+        throw new HttpException(
+          describeApiError(responseText, response.status),
+          response.status,
+          responseText,
+          {},
+          response.headers.get("retry-after")
+        );
+      }
+      return this.parseResponse(responseText, response.status);
+    });
+    const token = Token.fromArray(data);
+    this.tokenStorage.set(token);
+    return token;
+  }
+  async loginWithClientId(clientId, password, device) {
+    return this.login(clientId, password, device, LoginIdentifier.CLIENT_ID);
+  }
+  async refresh() {
+    const storedToken = this.tokenStorage.get();
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey
+    };
+    if (storedToken) {
+      headers["Authorization"] = `Bearer ${storedToken.accessToken}`;
+    }
+    const data = await withRetries(this.retryPolicy, "token refresh", async () => {
+      const response = await this.httpClient.request("POST", `${this.baseUrl}/auth/refresh`, { headers });
+      const responseText = await response.text();
+      if (response.status === 401) {
+        throw new AuthenticationException("Token refresh failed: unauthorized", { status: 401, body: responseText });
+      }
+      if (!response.ok) {
+        throw new HttpException(
+          describeApiError(responseText, response.status),
+          response.status,
+          responseText,
+          {},
+          response.headers.get("retry-after")
+        );
+      }
+      return this.parseResponse(responseText, response.status);
+    });
+    const token = Token.fromArray(data);
+    this.tokenStorage.set(token);
+    return token;
+  }
+  parseResponse(responseText, statusCode) {
+    let parsed;
+    try {
+      parsed = JSON.parse(responseText);
+    } catch {
+      throw new HttpException("Invalid JSON response", statusCode, responseText);
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new HttpException("Unexpected response format", statusCode, responseText);
+    }
+    const obj = parsed;
+    if (obj["data"] !== void 0 && typeof obj["data"] === "object" && obj["data"] !== null) {
+      return obj["data"];
+    }
+    return obj;
+  }
+};
+
+// src/dto/CompanyResource.ts
+function normalizeCompanyResource(data) {
+  const apiRateLimit = typeof data["api_rate_limit"] === "number" ? data["api_rate_limit"] : void 0;
+  const vatRateLimit = typeof data["vat_rate_limit"] === "number" ? data["vat_rate_limit"] : void 0;
+  const legacyRateLimit = typeof data["rate_limit"] === "number" ? data["rate_limit"] : void 0;
+  return {
+    ...data,
+    api_rate_limit: apiRateLimit ?? legacyRateLimit ?? 0,
+    vat_rate_limit: vatRateLimit ?? legacyRateLimit ?? 0
+  };
+}
+
+// src/endpoints/CompanyEndpoint.ts
+var CompanyEndpoint = class {
+  constructor(baseUrl, apiKey, tokenStorage, httpClient, retryPolicy = new RetryPolicy()) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.tokenStorage = tokenStorage;
+    this.httpClient = httpClient;
+    this.retryPolicy = retryPolicy;
+  }
+  baseUrl;
+  apiKey;
+  tokenStorage;
+  httpClient;
+  retryPolicy;
+  async get() {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey
+    };
+    const token = this.tokenStorage.get();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token.accessToken}`;
+    }
+    return withRetries(this.retryPolicy, "company request", async () => {
+      const response = await this.httpClient.request("GET", `${this.baseUrl}/company`, { headers });
+      const responseText = await response.text();
+      if (!response.ok) {
+        throw new HttpException(
+          describeApiError(responseText, response.status),
+          response.status,
+          responseText,
+          {},
+          response.headers.get("retry-after")
+        );
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(responseText);
+      } catch {
+        throw new HttpException("Invalid JSON response", response.status, responseText);
+      }
+      if (typeof parsed !== "object" || parsed === null) {
+        throw new HttpException("Unexpected response format", response.status, responseText);
+      }
+      const obj = parsed;
+      if (obj["data"] !== void 0 && typeof obj["data"] === "object" && obj["data"] !== null) {
+        return normalizeCompanyResource(obj["data"]);
+      }
+      return normalizeCompanyResource(obj);
+    });
+  }
+};
+
+// src/enums/ComplianceEnrollmentStatus.ts
+var ComplianceEnrollmentStatus = {
+  PENDING_DATA: "pending_data",
+  ACCOUNT_CREATED: "account_created",
+  REGIME_ACTIVATED: "regime_activated",
+  READY: "ready",
+  SUSPENDED: "suspended",
+  ERROR_ACCOUNT: "error_account",
+  ERROR_ACTIVATION: "error_activation",
+  UNKNOWN: "unknown"
+};
+var VALUES = Object.values(ComplianceEnrollmentStatus);
+function toComplianceEnrollmentStatus(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return ComplianceEnrollmentStatus.UNKNOWN;
+}
+var DESCRIPTIONS = {
+  [ComplianceEnrollmentStatus.PENDING_DATA]: "Awaiting merchant data before provisioning can start.",
+  [ComplianceEnrollmentStatus.ACCOUNT_CREATED]: "Provider account exists. Regime not yet activated.",
+  [ComplianceEnrollmentStatus.REGIME_ACTIVATED]: "Compliance regime activated at provider. Ready to submit transactions.",
+  [ComplianceEnrollmentStatus.READY]: "Enrollment fully active and reporting.",
+  [ComplianceEnrollmentStatus.SUSPENDED]: "Enrollment temporarily suspended.",
+  [ComplianceEnrollmentStatus.ERROR_ACCOUNT]: "Provider account creation failed.",
+  [ComplianceEnrollmentStatus.ERROR_ACTIVATION]: "Regime activation at provider failed.",
+  [ComplianceEnrollmentStatus.UNKNOWN]: "Unknown status."
+};
+function describeComplianceEnrollmentStatus(status) {
+  return DESCRIPTIONS[status];
+}
+
+// src/dto/ComplianceEnrollment.ts
+function asString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNullableString(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber(value) {
+  return typeof value === "number" ? value : Number(value ?? 0) || 0;
+}
+var ComplianceEnrollment = class _ComplianceEnrollment {
+  constructor(id, companyId, country, regime, provider, status, statusLabel, statusError, providerAccountId, taxId, companyRegisterId, companyRegisterScheme, regimeConfig, reportingStartDate, notificationEmail, autoSend, createdAt, updatedAt) {
+    this.id = id;
+    this.companyId = companyId;
+    this.country = country;
+    this.regime = regime;
+    this.provider = provider;
+    this.status = status;
+    this.statusLabel = statusLabel;
+    this.statusError = statusError;
+    this.providerAccountId = providerAccountId;
+    this.taxId = taxId;
+    this.companyRegisterId = companyRegisterId;
+    this.companyRegisterScheme = companyRegisterScheme;
+    this.regimeConfig = regimeConfig;
+    this.reportingStartDate = reportingStartDate;
+    this.notificationEmail = notificationEmail;
+    this.autoSend = autoSend;
+    this.createdAt = createdAt;
+    this.updatedAt = updatedAt;
+  }
+  id;
+  companyId;
+  country;
+  regime;
+  provider;
+  status;
+  statusLabel;
+  statusError;
+  providerAccountId;
+  taxId;
+  companyRegisterId;
+  companyRegisterScheme;
+  regimeConfig;
+  reportingStartDate;
+  notificationEmail;
+  autoSend;
+  createdAt;
+  updatedAt;
+  static fromArray(data) {
+    const regimeConfig = typeof data["regime_config"] === "object" && data["regime_config"] !== null && !Array.isArray(data["regime_config"]) ? data["regime_config"] : null;
+    return new _ComplianceEnrollment(
+      asNumber(data["id"]),
+      asNumber(data["company_id"]),
+      asString(data["country"]),
+      asString(data["regime"]),
+      asString(data["provider"]),
+      toComplianceEnrollmentStatus(data["status"]),
+      asString(data["status_label"]),
+      asNullableString(data["status_error"]),
+      asNullableString(data["provider_account_id"]),
+      asNullableString(data["tax_id"]),
+      asNullableString(data["company_register_id"]),
+      asNullableString(data["company_register_scheme"]),
+      regimeConfig,
+      asNullableString(data["reporting_start_date"]),
+      asNullableString(data["notification_email"]),
+      data["auto_send"] === true,
+      asNullableString(data["created_at"]),
+      asNullableString(data["updated_at"])
+    );
+  }
+};
+
+// src/dto/ComplianceEnrollmentPage.ts
+var ComplianceEnrollmentPage = class _ComplianceEnrollmentPage {
+  constructor(rows, currentPage, perPage, total, lastPage) {
+    this.rows = rows;
+    this.currentPage = currentPage;
+    this.perPage = perPage;
+    this.total = total;
+    this.lastPage = lastPage;
+  }
+  rows;
+  currentPage;
+  perPage;
+  total;
+  lastPage;
+  static fromResponse(payload) {
+    const obj = payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    const rows = Array.isArray(obj["data"]) ? obj["data"].filter((row) => typeof row === "object" && row !== null).map(ComplianceEnrollment.fromArray) : [];
+    const meta = obj["meta"] !== null && typeof obj["meta"] === "object" && !Array.isArray(obj["meta"]) ? obj["meta"] : {};
+    const num = (value, fallback) => typeof value === "number" ? value : fallback;
+    return new _ComplianceEnrollmentPage(
+      rows,
+      num(meta["current_page"], 1),
+      num(meta["per_page"], rows.length),
+      num(meta["total"], rows.length),
+      num(meta["last_page"], 1)
+    );
+  }
+  [Symbol.iterator]() {
+    return this.rows[Symbol.iterator]();
+  }
+  get length() {
+    return this.rows.length;
+  }
+};
+
+// src/enums/ComplianceTaxReportState.ts
+var ComplianceTaxReportState = {
+  NEW: "new",
+  SENT: "sent",
+  ACKNOWLEDGED: "acknowledged",
+  REGISTERED: "registered",
+  REFUSED: "refused",
+  ERROR: "error",
+  UNKNOWN: "unknown"
+};
+var VALUES2 = Object.values(ComplianceTaxReportState);
+function toComplianceTaxReportState(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES2.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return ComplianceTaxReportState.UNKNOWN;
+}
+var DESCRIPTIONS2 = {
+  [ComplianceTaxReportState.NEW]: "Created at provider, waiting for the daily ledger batch.",
+  [ComplianceTaxReportState.SENT]: "Ledger transmitted to PPF.",
+  [ComplianceTaxReportState.ACKNOWLEDGED]: "PPF acknowledged receipt of the ledger.",
+  [ComplianceTaxReportState.REGISTERED]: "Accepted by DGFiP (CDV 300).",
+  [ComplianceTaxReportState.REFUSED]: "Rejected by DGFiP (CDV 301).",
+  [ComplianceTaxReportState.ERROR]: "Transmission or PPF error.",
+  [ComplianceTaxReportState.UNKNOWN]: "Unknown state."
+};
+function describeComplianceTaxReportState(state) {
+  return DESCRIPTIONS2[state];
+}
+
+// src/dto/ComplianceTaxReport.ts
+function asString2(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNullableString2(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber2(value) {
+  return typeof value === "number" ? value : Number(value ?? 0) || 0;
+}
+function asNullableNumber(value) {
+  return typeof value === "number" ? value : null;
+}
+function asMoney(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return "0.00";
+}
+var ComplianceTaxReport = class _ComplianceTaxReport {
+  constructor(id, companyId, complianceTransactionId, ledgerId, country, regime, state, stateLabel, isTerminal, providerTaxReportId, providerLedgerId, baseAmount, taxAmount, totalAmount, refusalReason, registeredAt, refusedAt, createdAt, updatedAt) {
+    this.id = id;
+    this.companyId = companyId;
+    this.complianceTransactionId = complianceTransactionId;
+    this.ledgerId = ledgerId;
+    this.country = country;
+    this.regime = regime;
+    this.state = state;
+    this.stateLabel = stateLabel;
+    this.isTerminal = isTerminal;
+    this.providerTaxReportId = providerTaxReportId;
+    this.providerLedgerId = providerLedgerId;
+    this.baseAmount = baseAmount;
+    this.taxAmount = taxAmount;
+    this.totalAmount = totalAmount;
+    this.refusalReason = refusalReason;
+    this.registeredAt = registeredAt;
+    this.refusedAt = refusedAt;
+    this.createdAt = createdAt;
+    this.updatedAt = updatedAt;
+  }
+  id;
+  companyId;
+  complianceTransactionId;
+  ledgerId;
+  country;
+  regime;
+  state;
+  stateLabel;
+  isTerminal;
+  providerTaxReportId;
+  providerLedgerId;
+  baseAmount;
+  taxAmount;
+  totalAmount;
+  refusalReason;
+  registeredAt;
+  refusedAt;
+  createdAt;
+  updatedAt;
+  static fromArray(data) {
+    return new _ComplianceTaxReport(
+      asNumber2(data["id"]),
+      asNumber2(data["company_id"]),
+      asNullableNumber(data["compliance_transaction_id"]),
+      asNullableNumber(data["ledger_id"]),
+      asString2(data["country"]),
+      asString2(data["regime"]),
+      toComplianceTaxReportState(data["state"]),
+      asString2(data["state_label"]),
+      data["is_terminal"] === true,
+      asNullableString2(data["provider_tax_report_id"]),
+      asNullableString2(data["provider_ledger_id"]),
+      asMoney(data["base_amount"]),
+      asMoney(data["tax_amount"]),
+      asMoney(data["total_amount"]),
+      asNullableString2(data["refusal_reason"]),
+      asNullableString2(data["registered_at"]),
+      asNullableString2(data["refused_at"]),
+      asNullableString2(data["created_at"]),
+      asNullableString2(data["updated_at"])
+    );
+  }
+};
+
+// src/dto/ComplianceTaxReportPage.ts
+var ComplianceTaxReportPage = class _ComplianceTaxReportPage {
+  constructor(rows, currentPage, perPage, total, lastPage) {
+    this.rows = rows;
+    this.currentPage = currentPage;
+    this.perPage = perPage;
+    this.total = total;
+    this.lastPage = lastPage;
+  }
+  rows;
+  currentPage;
+  perPage;
+  total;
+  lastPage;
+  static fromResponse(payload) {
+    const obj = payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    const rows = Array.isArray(obj["data"]) ? obj["data"].filter((row) => typeof row === "object" && row !== null).map(ComplianceTaxReport.fromArray) : [];
+    const meta = obj["meta"] !== null && typeof obj["meta"] === "object" && !Array.isArray(obj["meta"]) ? obj["meta"] : {};
+    const num = (value, fallback) => typeof value === "number" ? value : fallback;
+    return new _ComplianceTaxReportPage(
+      rows,
+      num(meta["current_page"], 1),
+      num(meta["per_page"], rows.length),
+      num(meta["total"], rows.length),
+      num(meta["last_page"], 1)
+    );
+  }
+  [Symbol.iterator]() {
+    return this.rows[Symbol.iterator]();
+  }
+  get length() {
+    return this.rows.length;
+  }
+};
+
+// src/enums/ComplianceTransactionState.ts
+var ComplianceTransactionState = {
+  PENDING: "pending",
+  SENDING: "sending",
+  SUBMITTED: "submitted",
+  ERROR: "error",
+  UNKNOWN: "unknown"
+};
+var VALUES3 = Object.values(ComplianceTransactionState);
+function toComplianceTransactionState(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES3.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return ComplianceTransactionState.UNKNOWN;
+}
+var DESCRIPTIONS3 = {
+  [ComplianceTransactionState.PENDING]: "Recorded locally, not yet submitted to the provider.",
+  [ComplianceTransactionState.SENDING]: "Submission to the provider in progress.",
+  [ComplianceTransactionState.SUBMITTED]: "Successfully submitted to the provider.",
+  [ComplianceTransactionState.ERROR]: "Submission failed. See submissionError.",
+  [ComplianceTransactionState.UNKNOWN]: "Unknown state."
+};
+function describeComplianceTransactionState(state) {
+  return DESCRIPTIONS3[state];
+}
+
+// src/enums/ComplianceTransactionType.ts
+var ComplianceTransactionType = {
+  B2C_OUTBOUND: "b2c_outbound",
+  B2B_DOMESTIC_OUTBOUND: "b2b_domestic_outbound",
+  B2B_DOMESTIC_INBOUND: "b2b_domestic_inbound",
+  CROSSBORDER_OUTBOUND: "crossborder_outbound",
+  CROSSBORDER_INBOUND: "crossborder_inbound",
+  UNKNOWN: "unknown"
+};
+var VALUES4 = Object.values(ComplianceTransactionType);
+function toComplianceTransactionType(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES4.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return ComplianceTransactionType.UNKNOWN;
+}
+var DESCRIPTIONS4 = {
+  [ComplianceTransactionType.B2C_OUTBOUND]: "Sale to a private person in the merchant country (DGFiP Flux 10.3).",
+  [ComplianceTransactionType.B2B_DOMESTIC_OUTBOUND]: "Sale to a domestic business (DGFiP Flux 1, Phase 2).",
+  [ComplianceTransactionType.B2B_DOMESTIC_INBOUND]: "Purchase from a domestic business (DGFiP Flux 1, Phase 2).",
+  [ComplianceTransactionType.CROSSBORDER_OUTBOUND]: "Sale to a non-domestic business (DGFiP Flux 10.1).",
+  [ComplianceTransactionType.CROSSBORDER_INBOUND]: "Purchase from a non-domestic supplier (DGFiP Flux 10.1).",
+  [ComplianceTransactionType.UNKNOWN]: "Unknown transaction type."
+};
+function describeComplianceTransactionType(type) {
+  return DESCRIPTIONS4[type];
+}
+
+// src/dto/ComplianceTransaction.ts
+function asString3(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNullableString3(value) {
+  return typeof value === "string" ? value : null;
+}
+function asNumber3(value) {
+  return typeof value === "number" ? value : Number(value ?? 0) || 0;
+}
+function asMoney2(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return String(value);
+  return "0.00";
+}
+var ComplianceTransaction = class _ComplianceTransaction {
+  constructor(id, companyId, complianceEnrollmentId, country, regime, transactionType, transactionTypeLabel, state, stateLabel, invoiceNumber, invoiceDate, dueDate, currency, subtotal, taxAmount, total, counterpartyName, counterpartyCountry, counterpartyVatNumber, isPaid, paidAt, providerInvoiceId, submissionError, reportedAt, taxReport, createdAt, updatedAt) {
+    this.id = id;
+    this.companyId = companyId;
+    this.complianceEnrollmentId = complianceEnrollmentId;
+    this.country = country;
+    this.regime = regime;
+    this.transactionType = transactionType;
+    this.transactionTypeLabel = transactionTypeLabel;
+    this.state = state;
+    this.stateLabel = stateLabel;
+    this.invoiceNumber = invoiceNumber;
+    this.invoiceDate = invoiceDate;
+    this.dueDate = dueDate;
+    this.currency = currency;
+    this.subtotal = subtotal;
+    this.taxAmount = taxAmount;
+    this.total = total;
+    this.counterpartyName = counterpartyName;
+    this.counterpartyCountry = counterpartyCountry;
+    this.counterpartyVatNumber = counterpartyVatNumber;
+    this.isPaid = isPaid;
+    this.paidAt = paidAt;
+    this.providerInvoiceId = providerInvoiceId;
+    this.submissionError = submissionError;
+    this.reportedAt = reportedAt;
+    this.taxReport = taxReport;
+    this.createdAt = createdAt;
+    this.updatedAt = updatedAt;
+  }
+  id;
+  companyId;
+  complianceEnrollmentId;
+  country;
+  regime;
+  transactionType;
+  transactionTypeLabel;
+  state;
+  stateLabel;
+  invoiceNumber;
+  invoiceDate;
+  dueDate;
+  currency;
+  subtotal;
+  taxAmount;
+  total;
+  counterpartyName;
+  counterpartyCountry;
+  counterpartyVatNumber;
+  isPaid;
+  paidAt;
+  providerInvoiceId;
+  submissionError;
+  reportedAt;
+  taxReport;
+  createdAt;
+  updatedAt;
+  static fromArray(data) {
+    const taxReport = typeof data["tax_report"] === "object" && data["tax_report"] !== null && !Array.isArray(data["tax_report"]) ? ComplianceTaxReport.fromArray(data["tax_report"]) : void 0;
+    return new _ComplianceTransaction(
+      asNumber3(data["id"]),
+      asNumber3(data["company_id"]),
+      asNumber3(data["compliance_enrollment_id"]),
+      asString3(data["country"]),
+      asString3(data["regime"]),
+      toComplianceTransactionType(data["transaction_type"]),
+      asString3(data["transaction_type_label"]),
+      toComplianceTransactionState(data["state"]),
+      asString3(data["state_label"]),
+      asString3(data["invoice_number"]),
+      asNullableString3(data["invoice_date"]),
+      asNullableString3(data["due_date"]),
+      asString3(data["currency"], "EUR"),
+      asMoney2(data["subtotal"]),
+      asMoney2(data["tax_amount"]),
+      asMoney2(data["total"]),
+      asNullableString3(data["counterparty_name"]),
+      asNullableString3(data["counterparty_country"]),
+      asNullableString3(data["counterparty_vat_number"]),
+      data["is_paid"] === true,
+      asNullableString3(data["paid_at"]),
+      asNullableString3(data["provider_invoice_id"]),
+      asNullableString3(data["submission_error"]),
+      asNullableString3(data["reported_at"]),
+      taxReport,
+      asNullableString3(data["created_at"]),
+      asNullableString3(data["updated_at"])
+    );
+  }
+};
+
+// src/dto/ComplianceTransactionPage.ts
+var ComplianceTransactionPage = class _ComplianceTransactionPage {
+  constructor(rows, currentPage, perPage, total, lastPage) {
+    this.rows = rows;
+    this.currentPage = currentPage;
+    this.perPage = perPage;
+    this.total = total;
+    this.lastPage = lastPage;
+  }
+  rows;
+  currentPage;
+  perPage;
+  total;
+  lastPage;
+  static fromResponse(payload) {
+    const obj = payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    const rows = Array.isArray(obj["data"]) ? obj["data"].filter((row) => typeof row === "object" && row !== null).map(ComplianceTransaction.fromArray) : [];
+    const meta = obj["meta"] !== null && typeof obj["meta"] === "object" && !Array.isArray(obj["meta"]) ? obj["meta"] : {};
+    const num = (value, fallback) => typeof value === "number" ? value : fallback;
+    return new _ComplianceTransactionPage(
+      rows,
+      num(meta["current_page"], 1),
+      num(meta["per_page"], rows.length),
+      num(meta["total"], rows.length),
+      num(meta["last_page"], 1)
+    );
+  }
+  [Symbol.iterator]() {
+    return this.rows[Symbol.iterator]();
+  }
+  get length() {
+    return this.rows.length;
+  }
+};
+
+// src/dto/ImportResult.ts
+var ImportResult = class _ImportResult {
+  constructor(created, skippedDuplicates, errors) {
+    this.created = created;
+    this.skippedDuplicates = skippedDuplicates;
+    this.errors = errors;
+  }
+  created;
+  skippedDuplicates;
+  errors;
+  static fromArray(data) {
+    const errors = (Array.isArray(data["errors"]) ? data["errors"] : []).filter(
+      (row) => typeof row === "string"
+    );
+    const num = (value) => typeof value === "number" ? value : 0;
+    return new _ImportResult(num(data["created"]), num(data["skipped_duplicates"]), errors);
+  }
+};
+
+// src/dto/RevenueStatistics.ts
+function asString4(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber4(value) {
+  return typeof value === "number" ? value : Number(value ?? 0) || 0;
+}
+function asMoney3(value) {
+  return typeof value === "string" ? value : "0.0000";
+}
+function asRecords(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((row) => typeof row === "object" && row !== null);
+}
+function toTotals(data) {
+  return {
+    count: asNumber4(data["count"]),
+    subtotal: asMoney3(data["subtotal"]),
+    taxAmount: asMoney3(data["tax_amount"]),
+    total: asMoney3(data["total"])
+  };
+}
+var RevenueStatistics = class _RevenueStatistics {
+  constructor(dateFrom, dateTo, interval, primaryCurrency, isMultiCurrency, totals, timeSeries, byType, byCountry, byState, byCurrency) {
+    this.dateFrom = dateFrom;
+    this.dateTo = dateTo;
+    this.interval = interval;
+    this.primaryCurrency = primaryCurrency;
+    this.isMultiCurrency = isMultiCurrency;
+    this.totals = totals;
+    this.timeSeries = timeSeries;
+    this.byType = byType;
+    this.byCountry = byCountry;
+    this.byState = byState;
+    this.byCurrency = byCurrency;
+  }
+  dateFrom;
+  dateTo;
+  interval;
+  primaryCurrency;
+  isMultiCurrency;
+  totals;
+  timeSeries;
+  byType;
+  byCountry;
+  byState;
+  byCurrency;
+  static fromArray(data) {
+    const range = typeof data["range"] === "object" && data["range"] !== null ? data["range"] : {};
+    const totals = toTotals(
+      typeof data["totals"] === "object" && data["totals"] !== null ? data["totals"] : {}
+    );
+    const timeSeries = asRecords(data["time_series"]).map((row) => ({
+      bucket: asString4(row["bucket"]),
+      ...toTotals(row)
+    }));
+    const byType = asRecords(data["by_type"]).map((row) => ({
+      type: asString4(row["type"]),
+      typeLabel: asString4(row["type_label"]),
+      count: asNumber4(row["count"]),
+      total: asMoney3(row["total"])
+    }));
+    const byCountry = asRecords(data["by_country"]).map((row) => ({
+      country: asString4(row["country"], "unknown"),
+      count: asNumber4(row["count"]),
+      total: asMoney3(row["total"])
+    }));
+    const byState = asRecords(data["by_state"]).map((row) => ({
+      state: asString4(row["state"]),
+      stateLabel: asString4(row["state_label"]),
+      count: asNumber4(row["count"]),
+      total: asMoney3(row["total"])
+    }));
+    const byCurrency = asRecords(data["by_currency"]).map((row) => ({
+      currency: asString4(row["currency"]),
+      ...toTotals(row)
+    }));
+    return new _RevenueStatistics(
+      asString4(range["date_from"]) || void 0,
+      asString4(range["date_to"]) || void 0,
+      asString4(range["interval"]) || void 0,
+      asString4(data["primary_currency"], "EUR"),
+      data["is_multi_currency"] === true,
+      totals,
+      timeSeries,
+      byType,
+      byCountry,
+      byState,
+      byCurrency
+    );
+  }
+};
+
+// src/dto/SireneLookupResult.ts
+function asString5(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNullableString4(value) {
+  return typeof value === "string" ? value : null;
+}
+var SireneLookupResult = class _SireneLookupResult {
+  constructor(companyName, siren, siret, nafCode, nafFull, enterpriseSize, address, city, postalcode) {
+    this.companyName = companyName;
+    this.siren = siren;
+    this.siret = siret;
+    this.nafCode = nafCode;
+    this.nafFull = nafFull;
+    this.enterpriseSize = enterpriseSize;
+    this.address = address;
+    this.city = city;
+    this.postalcode = postalcode;
+  }
+  companyName;
+  siren;
+  siret;
+  nafCode;
+  nafFull;
+  enterpriseSize;
+  address;
+  city;
+  postalcode;
+  static fromArray(data) {
+    return new _SireneLookupResult(
+      asString5(data["company_name"]),
+      asString5(data["siren"]),
+      asNullableString4(data["siret"]),
+      asNullableString4(data["naf_code"]),
+      asNullableString4(data["naf_full"]),
+      asNullableString4(data["enterprise_size"]),
+      asNullableString4(data["address"]),
+      asNullableString4(data["city"]),
+      asNullableString4(data["postalcode"])
+    );
+  }
+};
+
+// src/dto/VatRates.ts
+function asString6(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber5(value) {
+  return typeof value === "number" ? value : Number(value ?? 0) || 0;
+}
+var VatRates = class _VatRates {
+  constructor(country, currency, rates) {
+    this.country = country;
+    this.currency = currency;
+    this.rates = rates;
+  }
+  country;
+  currency;
+  rates;
+  static fromArray(data) {
+    const rates = (Array.isArray(data["rates"]) ? data["rates"] : []).filter((row) => typeof row === "object" && row !== null).map((row) => ({
+      percent: asNumber5(row["percent"]),
+      category: asString6(row["category"]),
+      labelKey: asString6(row["label_key"]),
+      taxName: asString6(row["tax_name"]),
+      requiresVatex: row["requires_vatex"] === true
+    }));
+    return new _VatRates(asString6(data["country"]), asString6(data["currency"], "EUR"), rates);
+  }
+};
+
+// src/exceptions/ValidationException.ts
+var ValidationException = class extends TaxoraException {
+  statusCode = 422;
+  errors;
+  constructor(message, errors, context = {}) {
+    super(message, context);
+    this.name = "ValidationException";
+    this.errors = errors;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  getErrors() {
+    return this.errors;
+  }
+};
+
+// src/endpoints/EReportingEndpoint.ts
+var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var NAF_CODE_REGEX = /^\d{2}$/;
+var INTERVALS = ["day", "week", "month"];
+var ENTERPRISE_SIZES = ["micro", "pme", "eti", "ge"];
+var TYPE_OPERATIONS = ["services", "goods", "mixed"];
+var TRANSACTION_TYPES = [
+  "b2c_outbound",
+  "b2b_domestic_outbound",
+  "b2b_domestic_inbound",
+  "crossborder_outbound",
+  "crossborder_inbound"
+];
+var EReportingEndpoint = class {
+  constructor(baseUrl, apiKey, tokenStorage, httpClient, retryPolicy = new RetryPolicy()) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.tokenStorage = tokenStorage;
+    this.httpClient = httpClient;
+    this.retryPolicy = retryPolicy;
+  }
+  baseUrl;
+  apiKey;
+  tokenStorage;
+  httpClient;
+  retryPolicy;
+  // ---------------------------------------------------------------------
+  // Enrollments
+  // ---------------------------------------------------------------------
+  /**
+   * Create a compliance enrollment and provision the provider account. By
+   * default the DGFiP regime is activated right away; pass `autoActivate: false`
+   * to only create the account.
+   *
+   * On provider failure the API responds 502 (mapped to an HttpException) and
+   * the enrollment is persisted in `error_account`/`error_activation` state so
+   * provisioning can be retried.
+   */
+  async createEnrollment(input) {
+    this.validateEnrollmentInput(input);
+    const body = {
+      email: input.email,
+      naf_code: input.nafCode,
+      enterprise_size: input.enterpriseSize,
+      type_operation: input.typeOperation,
+      reporting_start_date: this.formatDate(input.reportingStartDate)
+    };
+    if (input.country !== void 0) body["country"] = input.country;
+    if (input.regime !== void 0) body["regime"] = input.regime;
+    if (input.siret !== void 0) body["siret"] = input.siret;
+    if (input.siren !== void 0) body["siren"] = input.siren;
+    if (input.vatNumber !== void 0) body["vat_number"] = input.vatNumber;
+    if (input.companyName !== void 0) body["company_name"] = input.companyName;
+    if (input.address !== void 0) body["address"] = input.address;
+    if (input.city !== void 0) body["city"] = input.city;
+    if (input.postalcode !== void 0) body["postalcode"] = input.postalcode;
+    if (input.province !== void 0) body["province"] = input.province;
+    if (input.autoActivate !== void 0) body["auto_activate"] = input.autoActivate;
+    const response = await this.sendRequest("POST", `${this.baseUrl}/compliance/enrollments`, body);
+    const data = await this.parseJsonResponse(response);
+    return ComplianceEnrollment.fromArray(data);
+  }
+  /** Paginated list of the company's enrollments (newest first). `perPage` is capped at 100 server-side. */
+  async listEnrollments(page = 1, perPage = 25) {
+    const params = new URLSearchParams();
+    params.set("page", String(page));
+    params.set("per_page", String(perPage));
+    const response = await this.sendRequest("GET", `${this.baseUrl}/compliance/enrollments?${params.toString()}`);
+    return ComplianceEnrollmentPage.fromResponse(await this.parseJsonResponse(response));
+  }
+  /** Get a single enrollment by id. */
+  async getEnrollment(id) {
+    this.validateId(id, "id");
+    const response = await this.sendRequest("GET", `${this.baseUrl}/compliance/enrollments/${id}`);
+    const data = await this.parseJsonResponse(response);
+    return ComplianceEnrollment.fromArray(data);
+  }
+  /**
+   * Look up company data by SIRET, SIREN or French VAT number via the French
+   * SIRENE registry — ideal for prefilling createEnrollment().
+   *
+   * Rate-limited to 3 requests/minute per user (protects the external French
+   * government API); exceeding it yields a 429 (mapped to an HttpException).
+   */
+  async sireneLookup(q) {
+    if (q.trim() === "") {
+      throw new TaxoraException("q must not be empty.");
+    }
+    const params = new URLSearchParams();
+    params.set("q", q);
+    const response = await this.sendRequest("GET", `${this.baseUrl}/compliance/sirene-lookup?${params.toString()}`);
+    const data = await this.parseJsonResponse(response);
+    return SireneLookupResult.fromArray(data);
+  }
+  // ---------------------------------------------------------------------
+  // Transactions
+  // ---------------------------------------------------------------------
+  /**
+   * Record and (by default) submit a Flux 10 transaction. Pass `submitNow: false`
+   * to only record it — submission can be triggered later via submitTransaction().
+   *
+   * Immediate per-invoice submission requires the e-invoicing feature on the
+   * account; in pure e-reporting mode the transaction is only recorded and
+   * reported via the aggregated daily ledgers.
+   *
+   * Creation is idempotent on the invoice's natural key (enrollment, type,
+   * invoice number, invoice date, counterparty VAT): a re-sent create returns
+   * the existing transaction with HTTP 200 instead of creating a duplicate.
+   *
+   * On provider failure the API responds 502 (mapped to an HttpException).
+   */
+  async createTransaction(input) {
+    this.validateId(input.complianceEnrollmentId, "complianceEnrollmentId");
+    this.validateTransactionType(input.transactionType);
+    this.validateInvoiceNumber(input.invoiceNumber);
+    this.validateInvoiceLines(input.invoiceLines);
+    this.validateOptionalCodes(input);
+    const body = {
+      compliance_enrollment_id: input.complianceEnrollmentId,
+      transaction_type: input.transactionType,
+      invoice_number: input.invoiceNumber,
+      invoice_date: this.formatDate(input.invoiceDate),
+      subtotal: input.subtotal,
+      total: input.total,
+      invoice_lines_attributes: this.buildInvoiceLines(input.invoiceLines)
+    };
+    this.applyOptionalTransactionFields(body, input);
+    if (input.submitNow !== void 0) body["submit_now"] = input.submitNow;
+    const response = await this.sendRequest("POST", `${this.baseUrl}/compliance/transactions`, body);
+    const data = await this.parseJsonResponse(response);
+    return ComplianceTransaction.fromArray(data);
+  }
+  /** Paginated list of the company's transactions (newest invoice date first), filterable by date / state / type. */
+  async listTransactions(filters = {}) {
+    const params = new URLSearchParams();
+    if (filters.dateFrom !== void 0) params.set("date_from", this.formatDate(filters.dateFrom));
+    if (filters.dateTo !== void 0) params.set("date_to", this.formatDate(filters.dateTo));
+    if (filters.state !== void 0) params.set("state", filters.state);
+    if (filters.transactionType !== void 0) params.set("transaction_type", filters.transactionType);
+    if (filters.page !== void 0) params.set("page", String(filters.page));
+    if (filters.perPage !== void 0) params.set("per_page", String(filters.perPage));
+    const queryString = params.toString();
+    const url = `${this.baseUrl}/compliance/transactions${queryString ? `?${queryString}` : ""}`;
+    const response = await this.sendRequest("GET", url);
+    return ComplianceTransactionPage.fromResponse(await this.parseJsonResponse(response));
+  }
+  /** Get a single transaction by id (includes its tax report when one exists). */
+  async getTransaction(id) {
+    this.validateId(id, "id");
+    const response = await this.sendRequest("GET", `${this.baseUrl}/compliance/transactions/${id}`);
+    const data = await this.parseJsonResponse(response);
+    return ComplianceTransaction.fromArray(data);
+  }
+  /** Update a still-pending transaction. Only the provided fields are sent; already-submitted transactions are rejected with 422. */
+  async updateTransaction(id, input) {
+    this.validateId(id, "id");
+    if (input.transactionType !== void 0) this.validateTransactionType(input.transactionType);
+    if (input.invoiceNumber !== void 0) this.validateInvoiceNumber(input.invoiceNumber);
+    if (input.invoiceLines !== void 0) this.validateInvoiceLines(input.invoiceLines);
+    this.validateOptionalCodes(input);
+    const body = {};
+    if (input.transactionType !== void 0) body["transaction_type"] = input.transactionType;
+    if (input.invoiceNumber !== void 0) body["invoice_number"] = input.invoiceNumber;
+    if (input.invoiceDate !== void 0) body["invoice_date"] = this.formatDate(input.invoiceDate);
+    if (input.subtotal !== void 0) body["subtotal"] = input.subtotal;
+    if (input.total !== void 0) body["total"] = input.total;
+    if (input.invoiceLines !== void 0) body["invoice_lines_attributes"] = this.buildInvoiceLines(input.invoiceLines);
+    this.applyOptionalTransactionFields(body, input);
+    const response = await this.sendRequest("PUT", `${this.baseUrl}/compliance/transactions/${id}`, body);
+    const data = await this.parseJsonResponse(response);
+    return ComplianceTransaction.fromArray(data);
+  }
+  /** Delete a still-pending transaction. Already-submitted transactions are rejected with 422. */
+  async deleteTransaction(id) {
+    this.validateId(id, "id");
+    const response = await this.sendRequest("DELETE", `${this.baseUrl}/compliance/transactions/${id}`);
+    await this.assertNoContentResponse(response);
+  }
+  /**
+   * Submit (or retry) an existing `pending`/`error` transaction to the provider.
+   * Replays the invoice lines stored at creation, so they don't have to be re-sent.
+   *
+   * Requires the e-invoicing feature on the account — pure e-reporting customers
+   * get a 422 (transactions are reported via the aggregated daily ledgers instead).
+   *
+   * On provider failure the API responds 502 (mapped to an HttpException);
+   * already-submitted transactions are rejected with 422.
+   */
+  async submitTransaction(id) {
+    this.validateId(id, "id");
+    const response = await this.sendRequest("POST", `${this.baseUrl}/compliance/transactions/${id}/submit`);
+    const data = await this.parseJsonResponse(response);
+    return ComplianceTransaction.fromArray(data);
+  }
+  /**
+   * Bulk-import transactions from a semicolon-separated CSV (one row per invoice
+   * line; rows sharing an invoice_number are grouped into one transaction).
+   * Required columns: invoice_number, invoice_date, transaction_type, subtotal,
+   * total, line_description, line_quantity, line_price, tax_name, tax_percent,
+   * tax_category.
+   *
+   * The import is idempotent: re-uploading the same file skips rows whose
+   * invoice already exists (reported via `skippedDuplicates`).
+   */
+  async importTransactions(enrollmentId, csvContent, filename = "transactions.csv") {
+    this.validateId(enrollmentId, "enrollmentId");
+    if (csvContent.trim() === "") {
+      throw new TaxoraException("csvContent must not be empty.");
+    }
+    const form = new FormData();
+    form.set("compliance_enrollment_id", String(enrollmentId));
+    form.set("file", new Blob([csvContent], { type: "text/csv" }), filename);
+    const response = await this.sendMultipartRequest("POST", `${this.baseUrl}/compliance/transactions/import`, form);
+    const data = await this.parseJsonResponse(response);
+    return ImportResult.fromArray(data);
+  }
+  // ---------------------------------------------------------------------
+  // Analytics, configuration & reports
+  // ---------------------------------------------------------------------
+  /**
+   * Aggregated turnover statistics for the authenticated company's e-reporting
+   * transactions. All arguments are optional — the API defaults to the last 12
+   * months and a monthly interval.
+   */
+  async getRevenueStatistics(filters = {}) {
+    if (filters.interval !== void 0 && !INTERVALS.includes(filters.interval)) {
+      throw new TaxoraException(
+        `Invalid statistics interval "${String(filters.interval)}". Expected one of: ${INTERVALS.join(", ")}.`
+      );
+    }
+    const params = new URLSearchParams();
+    if (filters.dateFrom !== void 0) params.set("date_from", this.formatDate(filters.dateFrom));
+    if (filters.dateTo !== void 0) params.set("date_to", this.formatDate(filters.dateTo));
+    if (filters.interval !== void 0) params.set("interval", filters.interval);
+    if (filters.transactionType !== void 0) params.set("transaction_type", filters.transactionType);
+    if (filters.state !== void 0) params.set("state", filters.state);
+    const queryString = params.toString();
+    const url = `${this.baseUrl}/compliance/revenue-statistics${queryString ? `?${queryString}` : ""}`;
+    const response = await this.sendRequest("GET", url);
+    const data = await this.parseJsonResponse(response);
+    return RevenueStatistics.fromArray(data);
+  }
+  /**
+   * The canonical VAT rates & DGFiP tax categories for a reporting country
+   * (the seller's reporting-country rates, not the counterparty's). Falls back
+   * to the configured default country (FR) when none/unknown is given.
+   */
+  async getVatRates(country) {
+    const params = new URLSearchParams();
+    if (country !== void 0) params.set("country", country);
+    const queryString = params.toString();
+    const url = `${this.baseUrl}/compliance/vat-rates${queryString ? `?${queryString}` : ""}`;
+    const response = await this.sendRequest("GET", url);
+    const data = await this.parseJsonResponse(response);
+    return VatRates.fromArray(data);
+  }
+  /** Paginated list of the company's tax reports (newest first), optionally filtered by state. */
+  async listTaxReports(page = 1, perPage = 25, state) {
+    const params = new URLSearchParams();
+    params.set("page", String(page));
+    params.set("per_page", String(perPage));
+    if (state !== void 0) params.set("state", state);
+    const response = await this.sendRequest("GET", `${this.baseUrl}/compliance/tax-reports?${params.toString()}`);
+    return ComplianceTaxReportPage.fromResponse(await this.parseJsonResponse(response));
+  }
+  /** Get a single tax report by id. */
+  async getTaxReport(id) {
+    this.validateId(id, "id");
+    const response = await this.sendRequest("GET", `${this.baseUrl}/compliance/tax-reports/${id}`);
+    const data = await this.parseJsonResponse(response);
+    return ComplianceTaxReport.fromArray(data);
+  }
+  /**
+   * Request activation of the E-Reporting feature for the account. This route
+   * is deliberately NOT gated by compliance access — it exists precisely for
+   * accounts that do not have the feature yet. The authenticated user's
+   * name/email take precedence over the form values server-side.
+   *
+   * Note: unlike the other compliance routes, validation failures here are
+   * returned as HTTP 400 (surfaced as HttpException), not 422.
+   */
+  async requestEReportingAccess(input = {}) {
+    const body = {};
+    if (input.name !== void 0) body["name"] = input.name;
+    if (input.email !== void 0) body["email"] = input.email;
+    if (input.company !== void 0) body["company"] = input.company;
+    if (input.phone !== void 0) body["phone"] = input.phone;
+    if (input.message !== void 0) body["message"] = input.message;
+    if (input.language !== void 0) body["language"] = input.language;
+    const response = await this.sendRequest("POST", `${this.baseUrl}/compliance/e-reporting-request`, body);
+    await this.parseJsonResponse(response);
+  }
+  // ---------------------------------------------------------------------
+  // Input validation (fail fast, before any request is sent)
+  // ---------------------------------------------------------------------
+  validateEnrollmentInput(input) {
+    if (input.siret === void 0 && input.siren === void 0) {
+      throw new TaxoraException("Either siret or siren is required.");
+    }
+    if (input.siret !== void 0 && input.siret.length !== 14) {
+      throw new TaxoraException("siret must be exactly 14 characters.");
+    }
+    if (input.siren !== void 0 && input.siren.length !== 9) {
+      throw new TaxoraException("siren must be exactly 9 characters.");
+    }
+    if (input.email.trim() === "" || !input.email.includes("@")) {
+      throw new TaxoraException("email must be a valid email address.");
+    }
+    if (!NAF_CODE_REGEX.test(input.nafCode)) {
+      throw new TaxoraException('nafCode must be exactly 2 digits, e.g. "47".');
+    }
+    if (!ENTERPRISE_SIZES.includes(input.enterpriseSize)) {
+      throw new TaxoraException(
+        `Invalid enterpriseSize "${String(input.enterpriseSize)}". Expected one of: ${ENTERPRISE_SIZES.join(", ")}.`
+      );
+    }
+    if (!TYPE_OPERATIONS.includes(input.typeOperation)) {
+      throw new TaxoraException(
+        `Invalid typeOperation "${String(input.typeOperation)}". Expected one of: ${TYPE_OPERATIONS.join(", ")}.`
+      );
+    }
+    if (input.country !== void 0 && input.country.length !== 2) {
+      throw new TaxoraException("country must be a 2-character ISO 3166-1 alpha-2 code.");
+    }
+  }
+  validateId(id, name) {
+    if (!Number.isInteger(id) || id <= 0) {
+      throw new TaxoraException(`${name} must be a positive integer.`);
+    }
+  }
+  validateTransactionType(type) {
+    if (!TRANSACTION_TYPES.includes(type)) {
+      throw new TaxoraException(
+        `Invalid transactionType "${String(type)}". Expected one of: ${TRANSACTION_TYPES.join(", ")}.`
+      );
+    }
+  }
+  validateInvoiceNumber(invoiceNumber) {
+    if (invoiceNumber.trim() === "") {
+      throw new TaxoraException("invoiceNumber must not be empty.");
+    }
+    if (invoiceNumber.length > 50) {
+      throw new TaxoraException("invoiceNumber must not exceed 50 characters.");
+    }
+  }
+  validateInvoiceLines(lines) {
+    if (lines.length === 0) {
+      throw new TaxoraException("invoiceLines must contain at least one line.");
+    }
+    lines.forEach((line, index) => {
+      if (line.taxes.length === 0) {
+        throw new TaxoraException(`invoiceLines[${index}].taxes must contain at least one tax.`);
+      }
     });
-    const responseText = await response.text();
-    if (response.status === 401) {
-      throw new AuthenticationException("Authentication failed: invalid credentials", {
-        status: 401,
-        body: responseText
-      });
+  }
+  validateOptionalCodes(input) {
+    if (input.currency !== void 0 && input.currency.length !== 3) {
+      throw new TaxoraException("currency must be a 3-character ISO 4217 code.");
     }
-    if (!response.ok) {
-      throw new HttpException(`HTTP error ${response.status}`, response.status, responseText);
+    if (input.counterpartyCountry !== void 0 && input.counterpartyCountry.length !== 2) {
+      throw new TaxoraException("counterpartyCountry must be a 2-character ISO 3166-1 alpha-2 code.");
     }
-    const data = this.parseResponse(responseText);
-    const token = Token.fromArray(data);
-    this.tokenStorage.set(token);
-    return token;
   }
-  async loginWithClientId(clientId, password, device) {
-    return this.login(clientId, password, device, LoginIdentifier.CLIENT_ID);
+  // ---------------------------------------------------------------------
+  // Body building (camelCase input → snake_case wire format)
+  // ---------------------------------------------------------------------
+  buildInvoiceLines(lines) {
+    return lines.map((line) => {
+      const built = {
+        description: line.description,
+        quantity: line.quantity,
+        price: line.price,
+        taxes_attributes: line.taxes.map((tax) => {
+          const taxBuilt = {
+            name: tax.name,
+            percent: tax.percent,
+            category: tax.category
+          };
+          if (tax.comment !== void 0) taxBuilt["comment"] = tax.comment;
+          return taxBuilt;
+        })
+      };
+      if (line.unit !== void 0) built["unit"] = line.unit;
+      return built;
+    });
   }
-  async refresh() {
-    const storedToken = this.tokenStorage.get();
+  /** Applies the optional scalar fields shared by create and update. */
+  applyOptionalTransactionFields(body, input) {
+    if (input.dueDate !== void 0) body["due_date"] = this.formatDate(input.dueDate);
+    if (input.currency !== void 0) body["currency"] = input.currency;
+    if (input.taxAmount !== void 0) body["tax_amount"] = input.taxAmount;
+    if (input.counterpartyName !== void 0) body["counterparty_name"] = input.counterpartyName;
+    if (input.counterpartyCountry !== void 0) body["counterparty_country"] = input.counterpartyCountry;
+    if (input.counterpartyVatNumber !== void 0) body["counterparty_vat_number"] = input.counterpartyVatNumber;
+    if (input.providerContactId !== void 0) body["provider_contact_id"] = input.providerContactId;
+    if (input.paymentMethod !== void 0) body["payment_method"] = input.paymentMethod;
+    if (input.remittanceInformation !== void 0) body["remittance_information"] = input.remittanceInformation;
+    if (input.paymentMethodText !== void 0) body["payment_method_text"] = input.paymentMethodText;
+    if (input.paymentTerms !== void 0) body["payment_terms"] = input.paymentTerms;
+  }
+  // ---------------------------------------------------------------------
+  // HTTP plumbing (kept in sync with SmartEnrichmentEndpoint)
+  // ---------------------------------------------------------------------
+  buildHeaders(withJsonContentType = true) {
     const headers = {
-      "Content-Type": "application/json",
       "x-api-key": this.apiKey
     };
-    if (storedToken) {
-      headers["Authorization"] = `Bearer ${storedToken.accessToken}`;
+    if (withJsonContentType) {
+      headers["Content-Type"] = "application/json";
+    }
+    const token = this.tokenStorage.get();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token.accessToken}`;
     }
-    const response = await this.httpClient.request("POST", `${this.baseUrl}/auth/refresh`, { headers });
+    return headers;
+  }
+  async sendRequest(method, url, body) {
+    const options = { headers: this.buildHeaders() };
+    if (body) options.body = JSON.stringify(body);
+    const send = () => this.httpClient.request(method, url, options);
+    return method === "GET" ? withResponseRetries(this.retryPolicy, "e-reporting request", send) : send();
+  }
+  /** Multipart upload: Content-Type is left to fetch so the boundary is set correctly. */
+  async sendMultipartRequest(method, url, form) {
+    return this.httpClient.request(method, url, { headers: this.buildHeaders(false), body: form });
+  }
+  /** Accepts any 2xx response (e.g. 201 on create, 200 on idempotent replay). */
+  async parseJsonResponse(response) {
     const responseText = await response.text();
-    if (response.status === 401) {
-      throw new AuthenticationException("Token refresh failed: unauthorized", { status: 401, body: responseText });
+    if (response.status === 422) {
+      throw this.buildValidationException(responseText);
     }
     if (!response.ok) {
-      throw new HttpException(`HTTP error ${response.status}`, response.status, responseText);
+      throw new HttpException(
+        describeApiError(responseText, response.status),
+        response.status,
+        responseText,
+        {},
+        response.headers.get("retry-after")
+      );
     }
-    const data = this.parseResponse(responseText);
-    const token = Token.fromArray(data);
-    this.tokenStorage.set(token);
-    return token;
-  }
-  parseResponse(responseText) {
     let parsed;
     try {
       parsed = JSON.parse(responseText);
     } catch {
-      throw new HttpException("Invalid JSON response", 0, responseText);
+      throw new HttpException("Invalid JSON response", response.status, responseText);
     }
     if (typeof parsed !== "object" || parsed === null) {
-      throw new HttpException("Unexpected response format", 0, responseText);
+      throw new HttpException("Unexpected response format", response.status, responseText);
     }
     const obj = parsed;
     if (obj["data"] !== void 0 && typeof obj["data"] === "object" && obj["data"] !== null) {
@@ -220,33 +1753,589 @@ var AuthEndpoint = class {
     }
     return obj;
   }
+  /** For the 204 delete: keeps the shared 422/HTTP error mapping but never parses a body. */
+  async assertNoContentResponse(response) {
+    if (response.status === 204) {
+      return;
+    }
+    const responseText = await response.text();
+    if (response.status === 422) {
+      throw this.buildValidationException(responseText);
+    }
+    if (!response.ok) {
+      throw new HttpException(
+        describeApiError(responseText, response.status),
+        response.status,
+        responseText,
+        {},
+        response.headers.get("retry-after")
+      );
+    }
+  }
+  /**
+   * The backend emits two 422 shapes: Laravel FormRequest failures as
+   * `{message, errors: {field: [...]}}` and state-guard errors via returnError()
+   * as `{error: "reason"}`. Preserve the reason in both cases.
+   */
+  buildValidationException(responseText) {
+    let message = "Validation failed";
+    let errors = {};
+    try {
+      const parsed = JSON.parse(responseText);
+      if (parsed["errors"] !== null && typeof parsed["errors"] === "object" && !Array.isArray(parsed["errors"])) {
+        errors = parsed["errors"];
+      }
+      if (typeof parsed["message"] === "string" && parsed["message"] !== "") {
+        message = parsed["message"];
+      } else if (typeof parsed["error"] === "string" && parsed["error"] !== "") {
+        message = parsed["error"];
+      }
+    } catch {
+    }
+    return new ValidationException(message, errors, { responseBody: responseText });
+  }
+  /**
+   * Date objects are serialized from their LOCAL date parts — construct them as
+   * `new Date('2026-09-01T00:00:00')` (local midnight); a bare `new Date('2026-09-01')`
+   * is UTC midnight and shifts a day back in UTC-negative timezones.
+   */
+  formatDate(date) {
+    if (date instanceof Date) {
+      const year = date.getFullYear();
+      const month = String(date.getMonth() + 1).padStart(2, "0");
+      const day = String(date.getDate()).padStart(2, "0");
+      return `${year}-${month}-${day}`;
+    }
+    if (!DATE_REGEX.test(date)) {
+      throw new TaxoraException(`Invalid date format: "${date}". Expected YYYY-MM-DD.`);
+    }
+    return date;
+  }
 };
 
-// src/dto/CompanyResource.ts
-function normalizeCompanyResource(data) {
-  const apiRateLimit = typeof data["api_rate_limit"] === "number" ? data["api_rate_limit"] : void 0;
-  const vatRateLimit = typeof data["vat_rate_limit"] === "number" ? data["vat_rate_limit"] : void 0;
-  const legacyRateLimit = typeof data["rate_limit"] === "number" ? data["rate_limit"] : void 0;
-  return {
-    ...data,
-    api_rate_limit: apiRateLimit ?? legacyRateLimit ?? 0,
-    vat_rate_limit: vatRateLimit ?? legacyRateLimit ?? 0
-  };
+// src/enums/SmartEnrichmentMode.ts
+var SmartEnrichmentMode = {
+  DEFAULT: "default",
+  COMPLEX: "complex"
+};
+var VALUES5 = Object.values(SmartEnrichmentMode);
+function toSmartEnrichmentMode(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES5.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+var DESCRIPTIONS5 = {
+  [SmartEnrichmentMode.DEFAULT]: "One provider searches; a second is consulted only if it finds nothing.",
+  [SmartEnrichmentMode.COMPLEX]: "Two providers search independently and are cross-checked against the tax authority. Costs more."
+};
+function describeSmartEnrichmentMode(mode) {
+  return DESCRIPTIONS5[mode];
 }
 
-// src/endpoints/CompanyEndpoint.ts
-var CompanyEndpoint = class {
-  constructor(baseUrl, apiKey, tokenStorage, httpClient) {
+// src/enums/SmartEnrichmentStatus.ts
+var SmartEnrichmentStatus = {
+  FOUND: "found",
+  NO_VAT_EXISTS: "no_vat_exists",
+  NOT_FOUND: "not_found",
+  PROCESSING: "processing",
+  QUEUED: "queued",
+  COMPLETED: "completed",
+  FAILED: "failed",
+  UNKNOWN: "unknown"
+};
+var VALUES6 = Object.values(SmartEnrichmentStatus);
+function toSmartEnrichmentStatus(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES6.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return SmartEnrichmentStatus.UNKNOWN;
+}
+var DESCRIPTIONS6 = {
+  [SmartEnrichmentStatus.FOUND]: "A VAT number was resolved and confirmed.",
+  [SmartEnrichmentStatus.NO_VAT_EXISTS]: "The company was identified but has no VAT number.",
+  [SmartEnrichmentStatus.NOT_FOUND]: "No sufficiently-confident match could be resolved.",
+  [SmartEnrichmentStatus.PROCESSING]: "The lookup is still being processed.",
+  [SmartEnrichmentStatus.QUEUED]: "The job is queued.",
+  [SmartEnrichmentStatus.COMPLETED]: "The job has completed.",
+  [SmartEnrichmentStatus.FAILED]: "The job failed.",
+  [SmartEnrichmentStatus.UNKNOWN]: "Unknown status."
+};
+function describeSmartEnrichmentStatus(status) {
+  return DESCRIPTIONS6[status];
+}
+
+// src/dto/SmartEnrichmentResource.ts
+var SmartEnrichmentResource = class _SmartEnrichmentResource {
+  constructor(status, vatNumber, vatType, confidence, matchedCompanyName, matchedAddress, country, source, mode = void 0, providerVerdicts = [], addressQuality = void 0) {
+    this.status = status;
+    this.vatNumber = vatNumber;
+    this.vatType = vatType;
+    this.confidence = confidence;
+    this.matchedCompanyName = matchedCompanyName;
+    this.matchedAddress = matchedAddress;
+    this.country = country;
+    this.source = source;
+    this.mode = mode;
+    this.providerVerdicts = providerVerdicts;
+    this.addressQuality = addressQuality;
+  }
+  status;
+  vatNumber;
+  vatType;
+  confidence;
+  matchedCompanyName;
+  matchedAddress;
+  country;
+  source;
+  mode;
+  providerVerdicts;
+  addressQuality;
+  static fromArray(data) {
+    const str = (key) => {
+      const v = data[key];
+      return typeof v === "string" ? v : void 0;
+    };
+    const num = (key) => {
+      const v = data[key];
+      return typeof v === "number" ? v : void 0;
+    };
+    const verdicts = data["providerVerdicts"];
+    const quality = data["addressQuality"];
+    return new _SmartEnrichmentResource(
+      toSmartEnrichmentStatus(data["status"]),
+      str("vatNumber"),
+      str("vatType"),
+      num("confidence"),
+      str("matchedCompanyName"),
+      str("matchedAddress"),
+      str("country"),
+      str("source"),
+      toSmartEnrichmentMode(data["mode"]),
+      Array.isArray(verdicts) ? verdicts.filter((v) => typeof v === "object" && v !== null) : [],
+      typeof quality === "object" && quality !== null ? quality : void 0
+    );
+  }
+  toArray() {
+    return {
+      status: this.status,
+      vatNumber: this.vatNumber ?? null,
+      vatType: this.vatType ?? null,
+      confidence: this.confidence ?? null,
+      matchedCompanyName: this.matchedCompanyName ?? null,
+      matchedAddress: this.matchedAddress ?? null,
+      country: this.country ?? null,
+      source: this.source ?? null,
+      mode: this.mode ?? null,
+      providerVerdicts: this.providerVerdicts,
+      addressQuality: this.addressQuality ?? null
+    };
+  }
+};
+
+// src/dto/SmartEnrichmentJob.ts
+var SmartEnrichmentJob = class _SmartEnrichmentJob {
+  constructor(jobId, status, itemCount, completedCount, foundCount, results) {
+    this.jobId = jobId;
+    this.status = status;
+    this.itemCount = itemCount;
+    this.completedCount = completedCount;
+    this.foundCount = foundCount;
+    this.results = results;
+  }
+  jobId;
+  status;
+  itemCount;
+  completedCount;
+  foundCount;
+  results;
+  static fromArray(data) {
+    const num = (key) => {
+      const v = data[key];
+      return typeof v === "number" ? v : void 0;
+    };
+    let results = [];
+    if (Array.isArray(data["results"])) {
+      results = data["results"].filter((row) => typeof row === "object" && row !== null).map(SmartEnrichmentResource.fromArray);
+    } else if (data["vatNumber"] !== void 0 || _SmartEnrichmentJob.looksLikeItem(data["status"])) {
+      results = [SmartEnrichmentResource.fromArray(data)];
+    }
+    return new _SmartEnrichmentJob(
+      typeof data["jobId"] === "string" ? data["jobId"] : "",
+      toSmartEnrichmentStatus(data["status"]),
+      num("itemCount"),
+      num("completedCount"),
+      num("foundCount"),
+      results
+    );
+  }
+  isProcessing() {
+    return this.status === SmartEnrichmentStatus.PROCESSING || this.status === SmartEnrichmentStatus.QUEUED;
+  }
+  /** Convenience for single lookups: the first (or only) result, if any. */
+  result() {
+    return this.results[0];
+  }
+  static looksLikeItem(status) {
+    const s = toSmartEnrichmentStatus(status);
+    return s === SmartEnrichmentStatus.FOUND || s === SmartEnrichmentStatus.NO_VAT_EXISTS || s === SmartEnrichmentStatus.NOT_FOUND;
+  }
+};
+
+// src/dto/SmartEnrichmentHistoryRow.ts
+var SmartEnrichmentHistoryRow = class _SmartEnrichmentHistoryRow {
+  constructor(jobId, status, isBulk, itemCount, foundCount, queryCompanyName, queryCountry, queryCity, input, result, createdAt, finishedAt) {
+    this.jobId = jobId;
+    this.status = status;
+    this.isBulk = isBulk;
+    this.itemCount = itemCount;
+    this.foundCount = foundCount;
+    this.queryCompanyName = queryCompanyName;
+    this.queryCountry = queryCountry;
+    this.queryCity = queryCity;
+    this.input = input;
+    this.result = result;
+    this.createdAt = createdAt;
+    this.finishedAt = finishedAt;
+  }
+  jobId;
+  status;
+  isBulk;
+  itemCount;
+  foundCount;
+  queryCompanyName;
+  queryCountry;
+  queryCity;
+  input;
+  result;
+  createdAt;
+  finishedAt;
+  static fromArray(data) {
+    const str = (value) => typeof value === "string" ? value : void 0;
+    const query = data["query"] !== null && typeof data["query"] === "object" && !Array.isArray(data["query"]) ? data["query"] : {};
+    const inputRaw = data["input"] !== null && typeof data["input"] === "object" && !Array.isArray(data["input"]) ? data["input"] : void 0;
+    const input = inputRaw ? {
+      companyName: str(inputRaw["companyName"]),
+      street: str(inputRaw["street"]),
+      postalCode: str(inputRaw["postalCode"]),
+      city: str(inputRaw["city"]),
+      country: str(inputRaw["country"])
+    } : void 0;
+    const result = data["result"] !== null && typeof data["result"] === "object" && !Array.isArray(data["result"]) ? SmartEnrichmentResource.fromArray(data["result"]) : void 0;
+    return new _SmartEnrichmentHistoryRow(
+      str(data["jobId"]) ?? "",
+      toSmartEnrichmentStatus(data["status"]),
+      data["isBulk"] === true,
+      typeof data["itemCount"] === "number" ? data["itemCount"] : 0,
+      typeof data["foundCount"] === "number" ? data["foundCount"] : 0,
+      str(query["companyName"]),
+      str(query["country"]),
+      str(query["city"]),
+      input,
+      result,
+      str(data["createdAt"]),
+      str(data["finishedAt"])
+    );
+  }
+};
+
+// src/dto/SmartEnrichmentHistoryPage.ts
+var SmartEnrichmentHistoryPage = class _SmartEnrichmentHistoryPage {
+  constructor(rows, currentPage, perPage, total, lastPage, stats) {
+    this.rows = rows;
+    this.currentPage = currentPage;
+    this.perPage = perPage;
+    this.total = total;
+    this.lastPage = lastPage;
+    this.stats = stats;
+  }
+  rows;
+  currentPage;
+  perPage;
+  total;
+  lastPage;
+  stats;
+  static fromResponse(payload) {
+    const obj = payload !== null && typeof payload === "object" && !Array.isArray(payload) ? payload : {};
+    const rows = Array.isArray(obj["data"]) ? obj["data"].filter((row) => typeof row === "object" && row !== null).map(SmartEnrichmentHistoryRow.fromArray) : [];
+    const meta = obj["meta"] !== null && typeof obj["meta"] === "object" && !Array.isArray(obj["meta"]) ? obj["meta"] : {};
+    const num = (value, fallback) => typeof value === "number" ? value : fallback;
+    const statsRaw = obj["stats"] !== null && typeof obj["stats"] === "object" && !Array.isArray(obj["stats"]) ? obj["stats"] : void 0;
+    const stats = statsRaw ? { total: num(statsRaw["total"], 0), found: num(statsRaw["found"], 0) } : void 0;
+    return new _SmartEnrichmentHistoryPage(
+      rows,
+      num(meta["currentPage"], 1),
+      num(meta["perPage"], rows.length),
+      num(meta["total"], rows.length),
+      num(meta["lastPage"], 1),
+      stats
+    );
+  }
+  [Symbol.iterator]() {
+    return this.rows[Symbol.iterator]();
+  }
+  get length() {
+    return this.rows.length;
+  }
+};
+
+// src/dto/SmartEnrichmentStatistics.ts
+function asString7(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNumber6(value) {
+  return typeof value === "number" ? value : Number(value ?? 0) || 0;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function asRecords2(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((row) => typeof row === "object" && row !== null);
+}
+var SmartEnrichmentStatistics = class _SmartEnrichmentStatistics {
+  constructor(range, totals, timeSeries, bySource, byOutcome, confidenceBuckets) {
+    this.range = range;
+    this.totals = totals;
+    this.timeSeries = timeSeries;
+    this.bySource = bySource;
+    this.byOutcome = byOutcome;
+    this.confidenceBuckets = confidenceBuckets;
+  }
+  range;
+  totals;
+  timeSeries;
+  bySource;
+  byOutcome;
+  confidenceBuckets;
+  static fromArray(data) {
+    const range = asRecord(data["range"]);
+    const totals = asRecord(data["totals"]);
+    const timeSeries = asRecords2(data["time_series"]).map((row) => ({
+      bucket: asString7(row["bucket"]),
+      jobs: asNumber6(row["jobs"]),
+      items: asNumber6(row["items"]),
+      found: asNumber6(row["found"])
+    }));
+    const bySource = asRecords2(data["by_source"]).map((row) => ({
+      source: asString7(row["source"]),
+      jobs: asNumber6(row["jobs"]),
+      found: asNumber6(row["found"])
+    }));
+    const byOutcome = asRecords2(data["by_outcome"]).map((row) => ({
+      outcome: asString7(row["outcome"]),
+      count: asNumber6(row["count"])
+    }));
+    const confidenceBuckets = asRecords2(data["confidence_buckets"]).map((row) => ({
+      bucket: asString7(row["bucket"]),
+      count: asNumber6(row["count"])
+    }));
+    return new _SmartEnrichmentStatistics(
+      {
+        dateFrom: asString7(range["date_from"]),
+        dateTo: asString7(range["date_to"]),
+        interval: asString7(range["interval"])
+      },
+      {
+        jobs: asNumber6(totals["jobs"]),
+        items: asNumber6(totals["items"]),
+        found: asNumber6(totals["found"]),
+        foundRate: asNumber6(totals["found_rate"]),
+        avgConfidence: asNumber6(totals["avg_confidence"])
+      },
+      timeSeries,
+      bySource,
+      byOutcome,
+      confidenceBuckets
+    );
+  }
+};
+
+// src/endpoints/SmartEnrichmentEndpoint.ts
+var STATISTICS_INTERVALS = ["day", "week", "month"];
+var DEFAULT_POLL_INTERVAL_MS = 2e3;
+var DEFAULT_POLL_TIMEOUT_MS = 12e4;
+var SmartEnrichmentEndpoint = class {
+  constructor(baseUrl, apiKey, tokenStorage, httpClient, retryPolicy = new RetryPolicy()) {
     this.baseUrl = baseUrl;
     this.apiKey = apiKey;
     this.tokenStorage = tokenStorage;
     this.httpClient = httpClient;
+    this.retryPolicy = retryPolicy;
   }
   baseUrl;
   apiKey;
   tokenStorage;
   httpClient;
-  async get() {
+  retryPolicy;
+  /**
+   * Single reverse lookup. Returns a confident result synchronously, or a `processing`
+   * job (poll with get(job.jobId) or waitForCompletion(job.jobId)) when deeper resolution
+   * is needed.
+   */
+  async lookup(input) {
+    this.validateInput(input);
+    const body = {
+      companyName: input.companyName,
+      country: input.country
+    };
+    if (input.street !== void 0) body["street"] = input.street;
+    if (input.postalCode !== void 0) body["postalCode"] = input.postalCode;
+    if (input.city !== void 0) body["city"] = input.city;
+    if (input.mode !== void 0) body["mode"] = input.mode;
+    const response = await this.sendRequest("POST", `${this.baseUrl}/smart-enrichment`, body);
+    const data = await this.parseJsonResponse(response, [200, 202]);
+    return SmartEnrichmentJob.fromArray(data);
+  }
+  /**
+   * Bulk batch — always async. Returns a `processing` job; results arrive via the
+   * `enrichment.completed` webhook and are retrievable via get(job.jobId).
+   *
+   * @param mode Search depth for every row in the batch. A row carrying its own `mode` overrides
+   *             it, so a caller can pay for `complex` on just the rows that need it.
+   */
+  async bulkLookup(items, mode) {
+    if (items.length === 0) {
+      throw new TaxoraException("bulkLookup requires at least one item.");
+    }
+    items.forEach((item, index) => this.validateInput(item, `items[${index}]`));
+    const body = { items };
+    if (mode !== void 0) body["mode"] = mode;
+    const response = await this.sendRequest("POST", `${this.baseUrl}/smart-enrichment/bulk`, body);
+    const data = await this.parseJsonResponse(response, [200, 202]);
+    return SmartEnrichmentJob.fromArray(data);
+  }
+  /** Poll a job (single or bulk) by its id. */
+  async get(jobId) {
+    this.validateJobId(jobId);
+    const response = await this.sendRequest("GET", `${this.baseUrl}/smart-enrichment/${encodeURIComponent(jobId)}`);
+    const data = await this.parseJsonResponse(response);
+    return SmartEnrichmentJob.fromArray(data);
+  }
+  /**
+   * Poll get(jobId) until the job is no longer processing (completed, failed or resolved).
+   * Throws a TaxoraException when the job does not finish within `timeoutMs`.
+   */
+  async waitForCompletion(jobId, options = {}) {
+    this.validateJobId(jobId);
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_POLL_TIMEOUT_MS;
+    if (!Number.isFinite(pollIntervalMs) || pollIntervalMs <= 0) {
+      throw new TaxoraException("pollIntervalMs must be greater than 0.");
+    }
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+      throw new TaxoraException("timeoutMs must be greater than 0.");
+    }
+    const deadline = Date.now() + timeoutMs;
+    for (; ; ) {
+      const job = await this.get(jobId);
+      if (!job.isProcessing()) {
+        return job;
+      }
+      if (Date.now() + pollIntervalMs > deadline) {
+        throw new TaxoraException(`Smart Enrichment job "${jobId}" did not complete within ${timeoutMs}ms.`, {
+          jobId,
+          timeoutMs
+        });
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+  }
+  /**
+   * Paginated lookup history (newest first). `perPage` is capped at 100 server-side.
+   * `search` filters (free-text) over the queried company name and the resolved
+   * VAT number / matched company name.
+   */
+  async history(page = 1, perPage = 25, search) {
+    const params = new URLSearchParams();
+    params.set("page", String(page));
+    params.set("perPage", String(perPage));
+    if (search !== void 0) params.set("search", search);
+    const response = await this.sendRequest("GET", `${this.baseUrl}/smart-enrichment/history?${params.toString()}`);
+    return SmartEnrichmentHistoryPage.fromResponse(await this.parseRawJson(response));
+  }
+  /** Current billing-period quota usage, plus recent monthly billing entries. */
+  async usage() {
+    const response = await this.sendRequest("GET", `${this.baseUrl}/smart-enrichment/usage`);
+    const data = await this.parseJsonResponse(response);
+    return {
+      period: typeof data["period"] === "string" ? data["period"] : "",
+      used: typeof data["used"] === "number" ? data["used"] : 0,
+      included: typeof data["included"] === "number" ? data["included"] : 0,
+      remaining: typeof data["remaining"] === "number" ? data["remaining"] : 0,
+      overageCount: typeof data["overageCount"] === "number" ? data["overageCount"] : 0,
+      overagePrice: typeof data["overagePrice"] === "number" ? data["overagePrice"] : 0,
+      overageAmount: typeof data["overageAmount"] === "number" ? data["overageAmount"] : 0,
+      hardCap: typeof data["hardCap"] === "number" ? data["hardCap"] : null,
+      history: this.parseUsageHistory(data["history"])
+    };
+  }
+  /**
+   * Export the company's lookups as CSV (bulk-input shape plus the resolved VAT columns;
+   * bulk jobs are flattened to one line per input row). Returns the raw CSV text
+   * (UTF-8, BOM included by the API so Excel opens umlauts correctly).
+   */
+  async export(options = {}) {
+    const params = new URLSearchParams();
+    if (options.dateFrom !== void 0) params.set("date_from", options.dateFrom);
+    if (options.dateTo !== void 0) params.set("date_to", options.dateTo);
+    if (options.minConfidence !== void 0) params.set("min_confidence", String(options.minConfidence));
+    for (const status of options.status ?? []) {
+      params.append("status[]", status);
+    }
+    if (options.onlyFound !== void 0) params.set("only_found", options.onlyFound ? "1" : "0");
+    const queryString = params.toString();
+    const url = `${this.baseUrl}/smart-enrichment/export${queryString ? `?${queryString}` : ""}`;
+    const response = await this.sendRequest("GET", url);
+    return this.parseCsvResponse(response);
+  }
+  /**
+   * Aggregated lookup statistics: headline totals, a time series and breakdowns by
+   * source, outcome and confidence band. The API defaults to the last 12 months
+   * and a monthly interval.
+   */
+  async statistics(options = {}) {
+    if (options.interval !== void 0 && !STATISTICS_INTERVALS.includes(options.interval)) {
+      throw new TaxoraException(
+        `Invalid statistics interval "${String(options.interval)}". Expected one of: ${STATISTICS_INTERVALS.join(", ")}.`
+      );
+    }
+    const params = new URLSearchParams();
+    if (options.dateFrom !== void 0) params.set("date_from", options.dateFrom);
+    if (options.dateTo !== void 0) params.set("date_to", options.dateTo);
+    if (options.interval !== void 0) params.set("interval", options.interval);
+    const queryString = params.toString();
+    const url = `${this.baseUrl}/smart-enrichment/statistics${queryString ? `?${queryString}` : ""}`;
+    const response = await this.sendRequest("GET", url);
+    return SmartEnrichmentStatistics.fromArray(await this.parseRawJson(response));
+  }
+  // ---------------------------------------------------------------------
+  // Input validation (fail fast, before any request is sent)
+  // ---------------------------------------------------------------------
+  validateInput(input, context) {
+    const where = context ? ` (${context})` : "";
+    if (input.companyName.trim() === "") {
+      throw new TaxoraException(`companyName must not be empty${where}.`);
+    }
+    if (input.country.length !== 2) {
+      throw new TaxoraException(`country must be a 2-character ISO 3166-1 alpha-2 code${where}.`);
+    }
+  }
+  validateJobId(jobId) {
+    if (jobId.trim() === "") {
+      throw new TaxoraException("jobId must not be empty.");
+    }
+  }
+  // ---------------------------------------------------------------------
+  // HTTP plumbing (kept in sync with VatEndpoint)
+  // ---------------------------------------------------------------------
+  buildHeaders() {
     const headers = {
       "Content-Type": "application/json",
       "x-api-key": this.apiKey
@@ -255,25 +2344,113 @@ var CompanyEndpoint = class {
     if (token) {
       headers["Authorization"] = `Bearer ${token.accessToken}`;
     }
-    const response = await this.httpClient.request("GET", `${this.baseUrl}/company`, { headers });
+    return headers;
+  }
+  async sendRequest(method, url, body) {
+    const options = { headers: this.buildHeaders() };
+    if (body) options.body = JSON.stringify(body);
+    const send = () => this.httpClient.request(method, url, options);
+    return method === "GET" ? withResponseRetries(this.retryPolicy, "Smart Enrichment request", send) : send();
+  }
+  async parseJsonResponse(response, acceptedStatuses = [200]) {
     const responseText = await response.text();
-    if (!response.ok) {
-      throw new HttpException(`HTTP error ${response.status}`, response.status, responseText);
+    if (response.status === 422) {
+      throw new ValidationException(jsonErrorMessage(responseText) ?? "Validation failed", this.parseValidationErrors(responseText));
+    }
+    if (!response.ok && !acceptedStatuses.includes(response.status)) {
+      throw new HttpException(
+        describeApiError(responseText, response.status),
+        response.status,
+        responseText,
+        {},
+        response.headers.get("retry-after")
+      );
     }
     let parsed;
     try {
       parsed = JSON.parse(responseText);
     } catch {
-      throw new HttpException("Invalid JSON response", 0, responseText);
+      throw new HttpException("Invalid JSON response", response.status, responseText);
     }
     if (typeof parsed !== "object" || parsed === null) {
-      throw new HttpException("Unexpected response format", 0, responseText);
+      throw new HttpException("Unexpected response format", response.status, responseText);
     }
     const obj = parsed;
-    if (obj["data"] !== void 0 && typeof obj["data"] === "object" && obj["data"] !== null) {
-      return normalizeCompanyResource(obj["data"]);
+    if (obj["data"] !== void 0 && (typeof obj["data"] === "object" || Array.isArray(obj["data"]))) {
+      return obj["data"];
+    }
+    return obj;
+  }
+  /**
+   * Like parseJsonResponse but returns the whole object WITHOUT unwrapping `data` — used for
+   * the paginated history response (where `data` is the row array and `meta`/`stats` must be
+   * preserved) and the statistics response.
+   */
+  async parseRawJson(response) {
+    const responseText = await response.text();
+    if (response.status === 422) {
+      throw new ValidationException(jsonErrorMessage(responseText) ?? "Validation failed", this.parseValidationErrors(responseText));
+    }
+    if (!response.ok) {
+      throw new HttpException(
+        describeApiError(responseText, response.status),
+        response.status,
+        responseText,
+        {},
+        response.headers.get("retry-after")
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(responseText);
+    } catch {
+      throw new HttpException("Invalid JSON response", response.status, responseText);
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new HttpException("Unexpected response format", response.status, responseText);
+    }
+    return parsed;
+  }
+  /**
+   * For the CSV export: keeps the shared 422/HTTP error mapping but returns the body
+   * verbatim (text/csv) instead of parsing JSON.
+   */
+  async parseCsvResponse(response) {
+    const responseText = await response.text();
+    if (response.status === 422) {
+      throw new ValidationException(jsonErrorMessage(responseText) ?? "Validation failed", this.parseValidationErrors(responseText));
+    }
+    if (!response.ok) {
+      throw new HttpException(
+        describeApiError(responseText, response.status),
+        response.status,
+        responseText,
+        {},
+        response.headers.get("retry-after")
+      );
+    }
+    return responseText;
+  }
+  parseValidationErrors(responseText) {
+    try {
+      const parsed = JSON.parse(responseText);
+      if (parsed["errors"] !== null && typeof parsed["errors"] === "object" && !Array.isArray(parsed["errors"])) {
+        return parsed["errors"];
+      }
+    } catch {
     }
-    return normalizeCompanyResource(obj);
+    return {};
+  }
+  parseUsageHistory(value) {
+    if (!Array.isArray(value)) return [];
+    return value.filter((row) => typeof row === "object" && row !== null).map((row) => ({
+      period: typeof row["period"] === "string" ? row["period"] : "",
+      matches: typeof row["matches"] === "number" ? row["matches"] : 0,
+      amount: typeof row["amount"] === "string" ? row["amount"] : "0.00",
+      state: row["state"] === "billed" ? "billed" : "pending",
+      billingType: typeof row["billingType"] === "string" ? row["billingType"] : null,
+      manualReference: typeof row["manualReference"] === "string" ? row["manualReference"] : null
+    }));
   }
 };
 
@@ -287,14 +2464,14 @@ var VatState = {
 function getFailedVatStates() {
   return [VatState.INVALID, VatState.FRAUD];
 }
-var DESCRIPTIONS = {
+var DESCRIPTIONS7 = {
   [VatState.VALID]: "The VAT number is valid and active.",
   [VatState.INVALID]: "The VAT number is invalid or not registered.",
   [VatState.FRAUD]: "The VAT number has been flagged as potentially fraudulent.",
   [VatState.UNKNOWN]: "The VAT number state could not be determined."
 };
 function describeVatState(state) {
-  return DESCRIPTIONS[state];
+  return DESCRIPTIONS7[state];
 }
 
 // src/dto/CompanyAddress.ts
@@ -756,34 +2933,21 @@ var VatValidationAddressInput = class _VatValidationAddressInput {
   }
 };
 
-// src/exceptions/ValidationException.ts
-var ValidationException = class extends TaxoraException {
-  statusCode = 422;
-  errors;
-  constructor(message, errors, context = {}) {
-    super(message, context);
-    this.name = "ValidationException";
-    this.errors = errors;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-  getErrors() {
-    return this.errors;
-  }
-};
-
 // src/endpoints/VatEndpoint.ts
-var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
+var DATE_REGEX2 = /^\d{4}-\d{2}-\d{2}$/;
 var VatEndpoint = class {
-  constructor(baseUrl, apiKey, tokenStorage, httpClient) {
+  constructor(baseUrl, apiKey, tokenStorage, httpClient, retryPolicy = new RetryPolicy()) {
     this.baseUrl = baseUrl;
     this.apiKey = apiKey;
     this.tokenStorage = tokenStorage;
     this.httpClient = httpClient;
+    this.retryPolicy = retryPolicy;
   }
   baseUrl;
   apiKey;
   tokenStorage;
   httpClient;
+  retryPolicy;
   async validate(vatUid, companyName, provider, addressInput) {
     const body = { vat_uid: vatUid };
     if (companyName) body["company_name"] = companyName;
@@ -791,44 +2955,44 @@ var VatEndpoint = class {
     if (addressInput) {
       body["address_input"] = addressInput instanceof VatValidationAddressInput ? addressInput.toArray() : addressInput;
     }
-    return this.validateWithGatewayRetry(body, 2);
-  }
-  async validateWithGatewayRetry(body, attemptsLeft) {
-    const response = await this.sendRequest("POST", `${this.baseUrl}/vat/validate`, body);
-    if (response.status === 504) {
-      if (attemptsLeft <= 1) {
-        const text = await response.text();
-        throw new HttpException("VAT validation timed out after multiple attempts", 504, text);
-      }
-      return this.validateWithGatewayRetry(body, attemptsLeft - 1);
-    }
-    const data = await this.parseJsonResponse(response);
-    return VatResource.fromArray(data);
+    return withRetries(this.retryPolicy, "VAT validation", async () => {
+      const response = await this.sendRequest("POST", `${this.baseUrl}/vat/validate`, body);
+      const data = await this.parseJsonResponse(response);
+      return VatResource.fromArray(data);
+    });
   }
   async validateMultiple(vatUids, companyNames, provider) {
     const body = { vat_uids: vatUids };
     if (companyNames) body["company_names"] = companyNames;
     if (provider) body["source"] = provider;
-    const response = await this.sendRequest("POST", `${this.baseUrl}/vat/validate/multiple`, body);
-    const data = await this.parseJsonResponse(response);
-    return VatCollection.fromResponse(data);
+    return withRetries(this.retryPolicy, "VAT validation", async () => {
+      const response = await this.sendRequest("POST", `${this.baseUrl}/vat/validate/multiple`, body);
+      const data = await this.parseJsonResponse(response);
+      return VatCollection.fromResponse(data);
+    });
   }
   async validateSchema(vatUid) {
     const body = { vat_uid: vatUid };
-    const response = await this.sendRequest("POST", `${this.baseUrl}/vat/validate/schema`, body);
-    return this.parseJsonResponse(response);
+    return withRetries(this.retryPolicy, "VAT schema check", async () => {
+      const response = await this.sendRequest("POST", `${this.baseUrl}/vat/validate/schema`, body);
+      return this.parseJsonResponse(response);
+    });
   }
   async state(vatUid) {
-    const response = await this.sendRequest("GET", `${this.baseUrl}/vat/state/${encodeURIComponent(vatUid)}`);
-    const data = await this.parseJsonResponse(response);
-    return VatResource.fromArray(data);
+    return withRetries(this.retryPolicy, "VAT state lookup", async () => {
+      const response = await this.sendRequest("GET", `${this.baseUrl}/vat/state/${encodeURIComponent(vatUid)}`);
+      const data = await this.parseJsonResponse(response);
+      return VatResource.fromArray(data);
+    });
   }
   async history(vatUid) {
     let url = `${this.baseUrl}/vat/history`;
     if (vatUid) url += `?vat_uid=${encodeURIComponent(vatUid)}`;
-    const response = await this.sendRequest("GET", url);
-    const data = await this.parseJsonResponse(response);
-    return VatCollection.fromResponse(data);
+    return withRetries(this.retryPolicy, "VAT history request", async () => {
+      const response = await this.sendRequest("GET", url);
+      const data = await this.parseJsonResponse(response);
+      return VatCollection.fromResponse(data);
+    });
   }
   async search(term, perPage) {
     const params = new URLSearchParams();
@@ -836,16 +3000,20 @@ var VatEndpoint = class {
     if (perPage !== void 0) params.set("per_page", String(perPage));
     const queryString = params.toString();
     const url = `${this.baseUrl}/vat/search${queryString ? `?${queryString}` : ""}`;
-    const response = await this.sendRequest("GET", url);
-    const data = await this.parseJsonResponse(response);
-    return VatCollection.fromResponse(data);
+    return withRetries(this.retryPolicy, "VAT search", async () => {
+      const response = await this.sendRequest("GET", url);
+      const data = await this.parseJsonResponse(response);
+      return VatCollection.fromResponse(data);
+    });
   }
   async certificate(uuid, lang) {
     let url = `${this.baseUrl}/vat/certificate/${encodeURIComponent(uuid)}`;
     if (lang) url += `?lang=${lang}`;
-    const response = await this.sendBinaryRequest("GET", url);
-    const buffer = await response.arrayBuffer();
-    return new Uint8Array(buffer);
+    return withRetries(this.retryPolicy, "VAT certificate download", async () => {
+      const response = await this.sendBinaryRequest("GET", url);
+      const buffer = await response.arrayBuffer();
+      return new Uint8Array(buffer);
+    });
   }
   async certificatesBulkExport(fromDate, toDate, countries, lang) {
     return this.exportRequest(`${this.baseUrl}/vat/certificates/bulk-export`, fromDate, toDate, countries, lang);
@@ -869,9 +3037,11 @@ var VatEndpoint = class {
   }
   async downloadBulkExport(exportId) {
     const url = `${this.baseUrl}/vat/certificates/bulk-export/${encodeURIComponent(exportId)}/download`;
-    const response = await this.sendBinaryRequest("GET", url);
-    const buffer = await response.arrayBuffer();
-    return new Uint8Array(buffer);
+    return withRetries(this.retryPolicy, "VAT export download", async () => {
+      const response = await this.sendBinaryRequest("GET", url);
+      const buffer = await response.arrayBuffer();
+      return new Uint8Array(buffer);
+    });
   }
   buildHeaders() {
     const headers = {
@@ -895,7 +3065,13 @@ var VatEndpoint = class {
     const response = await this.httpClient.request(method, url, { headers });
     if (!response.ok) {
       const text = await response.text();
-      throw new HttpException(`HTTP error ${response.status}`, response.status, text);
+      throw new HttpException(
+        describeApiError(text, response.status),
+        response.status,
+        text,
+        {},
+        response.headers.get("retry-after")
+      );
     }
     return response;
   }
@@ -910,19 +3086,25 @@ var VatEndpoint = class {
         }
       } catch {
       }
-      throw new ValidationException("Validation failed", errors);
+      throw new ValidationException(jsonErrorMessage(responseText) ?? "Validation failed", errors);
     }
     if (!response.ok && !acceptedStatuses.includes(response.status)) {
-      throw new HttpException(`HTTP error ${response.status}`, response.status, responseText);
+      throw new HttpException(
+        describeApiError(responseText, response.status),
+        response.status,
+        responseText,
+        {},
+        response.headers.get("retry-after")
+      );
     }
     let parsed;
     try {
       parsed = JSON.parse(responseText);
     } catch {
-      throw new HttpException("Invalid JSON response", 0, responseText);
+      throw new HttpException("Invalid JSON response", response.status, responseText);
     }
     if (typeof parsed !== "object" || parsed === null) {
-      throw new HttpException("Unexpected response format", 0, responseText);
+      throw new HttpException("Unexpected response format", response.status, responseText);
     }
     const obj = parsed;
     if (obj["data"] !== void 0 && (typeof obj["data"] === "object" || Array.isArray(obj["data"]))) {
@@ -937,7 +3119,7 @@ var VatEndpoint = class {
       const day = String(date.getDate()).padStart(2, "0");
       return `${year}-${month}-${day}`;
     }
-    if (!DATE_REGEX.test(date)) {
+    if (!DATE_REGEX2.test(date)) {
       throw new TaxoraException(`Invalid date format: "${date}". Expected YYYY-MM-DD.`);
     }
     return date;
@@ -1020,21 +3202,48 @@ var AuthRetryHttpClient = class {
   }
 };
 
+// src/version.ts
+var SDK_VERSION = "1.2.0";
+
+// src/http/SdkVersionHttpClient.ts
+var SDK_VERSION_HEADER = "X-Taxora-SDK-Version";
+var SDK_VERSION_VALUE = `taxora-node/${SDK_VERSION}`;
+var SdkVersionHttpClient = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  async request(method, url, options) {
+    const existing = options?.headers ?? {};
+    const headers = {
+      ...existing,
+      [SDK_VERSION_HEADER]: SDK_VERSION_VALUE
+    };
+    return this.inner.request(method, url, { ...options ?? {}, headers });
+  }
+};
+
 // src/client/TaxoraClient.ts
 var TaxoraClient = class {
   auth;
   vat;
   company;
+  smartEnrichment;
+  eReporting;
   baseUrl;
   constructor(options) {
     const environment = options.environment ?? Environment.SANDBOX;
     const tokenStorage = options.tokenStorage ?? new InMemoryTokenStorage();
     const httpClient = options.httpClient ?? new FetchHttpClient();
+    const retryPolicy = options.retryPolicy ?? new RetryPolicy();
+    const versionedClient = new SdkVersionHttpClient(httpClient);
     this.baseUrl = getBaseUrl(environment);
-    this.auth = new AuthEndpoint(this.baseUrl, options.apiKey, tokenStorage, httpClient);
-    const retryClient = new AuthRetryHttpClient(httpClient, tokenStorage, () => this.auth.refresh());
-    this.vat = new VatEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient);
-    this.company = new CompanyEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient);
+    this.auth = new AuthEndpoint(this.baseUrl, options.apiKey, tokenStorage, versionedClient, retryPolicy);
+    const retryClient = new AuthRetryHttpClient(versionedClient, tokenStorage, () => this.auth.refresh());
+    this.vat = new VatEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient, retryPolicy);
+    this.company = new CompanyEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient, retryPolicy);
+    this.smartEnrichment = new SmartEnrichmentEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient, retryPolicy);
+    this.eReporting = new EReportingEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient, retryPolicy);
   }
 };
 
@@ -1063,15 +3272,38 @@ var Language = {
   AuthenticationException,
   CompanyAddress,
   CompanyEndpoint,
+  ComplianceEnrollment,
+  ComplianceEnrollmentPage,
+  ComplianceEnrollmentStatus,
+  ComplianceTaxReport,
+  ComplianceTaxReportPage,
+  ComplianceTaxReportState,
+  ComplianceTransaction,
+  ComplianceTransactionPage,
+  ComplianceTransactionState,
+  ComplianceTransactionType,
+  EReportingEndpoint,
   Environment,
   FetchHttpClient,
   HttpException,
+  ImportResult,
   InMemoryTokenStorage,
   Language,
   LoginIdentifier,
   ProviderDocument,
   ProviderDocumentLine,
+  RetryPolicy,
+  RevenueStatistics,
   ScoreBreakdown,
+  SireneLookupResult,
+  SmartEnrichmentEndpoint,
+  SmartEnrichmentHistoryPage,
+  SmartEnrichmentHistoryRow,
+  SmartEnrichmentJob,
+  SmartEnrichmentMode,
+  SmartEnrichmentResource,
+  SmartEnrichmentStatistics,
+  SmartEnrichmentStatus,
   TaxoraClient,
   TaxoraClientFactory,
   TaxoraException,
@@ -1080,11 +3312,25 @@ var Language = {
   VatCertificateExport,
   VatCollection,
   VatEndpoint,
+  VatRates,
   VatResource,
   VatState,
   VatValidationAddressInput,
+  describeApiError,
+  describeComplianceEnrollmentStatus,
+  describeComplianceTaxReportState,
+  describeComplianceTransactionState,
+  describeComplianceTransactionType,
+  describeSmartEnrichmentMode,
+  describeSmartEnrichmentStatus,
   describeVatState,
   getBaseUrl,
-  getFailedVatStates
+  getFailedVatStates,
+  toComplianceEnrollmentStatus,
+  toComplianceTaxReportState,
+  toComplianceTransactionState,
+  toComplianceTransactionType,
+  toSmartEnrichmentMode,
+  toSmartEnrichmentStatus
 });
 //# sourceMappingURL=index.cjs.map