@taxora/sdk 1.1.0 → 1.3.0

package/dist/index.js

@@ -60,37 +60,293 @@ 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 ?? hostname();
     const body = {
@@ -103,24 +359,32 @@ 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 responseText = await response.text();
-    if (response.status === 401) {
-      throw new AuthenticationException("Authentication failed: invalid credentials", {
-        status: 401,
-        body: responseText
+    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)
       });
-    }
-    if (!response.ok) {
-      throw new HttpException(`HTTP error ${response.status}`, response.status, responseText);
-    }
-    const data = this.parseResponse(responseText);
+      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;
@@ -137,28 +401,36 @@ var AuthEndpoint = class {
     if (storedToken) {
       headers["Authorization"] = `Bearer ${storedToken.accessToken}`;
     }
-    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(`HTTP error ${response.status}`, response.status, responseText);
-    }
-    const data = this.parseResponse(responseText);
+    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) {
+  parseResponse(responseText, statusCode) {
     let parsed;
     try {
       parsed = JSON.parse(responseText);
     } catch {
-      throw new HttpException("Invalid JSON response", 0, responseText);
+      throw new HttpException("Invalid JSON response", statusCode, responseText);
     }
     if (typeof parsed !== "object" || parsed === null) {
-      throw new HttpException("Unexpected response format", 0, responseText);
+      throw new HttpException("Unexpected response format", statusCode, responseText);
     }
     const obj = parsed;
     if (obj["data"] !== void 0 && typeof obj["data"] === "object" && obj["data"] !== null) {
@@ -182,16 +454,18 @@ function normalizeCompanyResource(data) {
 
 // src/endpoints/CompanyEndpoint.ts
 var CompanyEndpoint = 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 get() {
     const headers = {
       "Content-Type": "application/json",
@@ -201,25 +475,33 @@ var CompanyEndpoint = class {
     if (token) {
       headers["Authorization"] = `Bearer ${token.accessToken}`;
     }
-    const response = await this.httpClient.request("GET", `${this.baseUrl}/company`, { headers });
-    const responseText = await response.text();
-    if (!response.ok) {
-      throw new HttpException(`HTTP error ${response.status}`, response.status, responseText);
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(responseText);
-    } catch {
-      throw new HttpException("Invalid JSON response", 0, responseText);
-    }
-    if (typeof parsed !== "object" || parsed === null) {
-      throw new HttpException("Unexpected response format", 0, responseText);
-    }
-    const obj = parsed;
-    if (obj["data"] !== void 0 && typeof obj["data"] === "object" && obj["data"] !== null) {
-      return normalizeCompanyResource(obj["data"]);
-    }
-    return normalizeCompanyResource(obj);
+    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);
+    });
   }
 };
 
@@ -258,6 +540,31 @@ function describeComplianceEnrollmentStatus(status) {
   return DESCRIPTIONS[status];
 }
 
+// src/enums/ComplianceService.ts
+var ComplianceService = {
+  E_REPORTING: "e_reporting",
+  E_INVOICING: "e_invoicing",
+  UNKNOWN: "unknown"
+};
+var VALUES2 = Object.values(ComplianceService);
+function toComplianceService(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES2.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return ComplianceService.UNKNOWN;
+}
+var DESCRIPTIONS2 = {
+  [ComplianceService.E_REPORTING]: "E-reporting of transaction data to the tax authority (France: DGFiP Flux 10).",
+  [ComplianceService.E_INVOICING]: "Structured e-invoices delivered to the buyer (Norway: EHF / Peppol BIS 3.0).",
+  [ComplianceService.UNKNOWN]: "Unknown service."
+};
+function describeComplianceService(service) {
+  return DESCRIPTIONS2[service];
+}
+
 // src/dto/ComplianceEnrollment.ts
 function asString(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
@@ -269,7 +576,7 @@ 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) {
+  constructor(id, companyId, country, regime, provider, status, statusLabel, statusError, providerAccountId, taxId, companyRegisterId, companyRegisterScheme, regimeConfig, reportingStartDate, notificationEmail, autoSend, createdAt, updatedAt, service = ComplianceService.UNKNOWN) {
     this.id = id;
     this.companyId = companyId;
     this.country = country;
@@ -288,6 +595,7 @@ var ComplianceEnrollment = class _ComplianceEnrollment {
     this.autoSend = autoSend;
     this.createdAt = createdAt;
     this.updatedAt = updatedAt;
+    this.service = service;
   }
   id;
   companyId;
@@ -307,6 +615,7 @@ var ComplianceEnrollment = class _ComplianceEnrollment {
   autoSend;
   createdAt;
   updatedAt;
+  service;
   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(
@@ -327,7 +636,8 @@ var ComplianceEnrollment = class _ComplianceEnrollment {
       asNullableString(data["notification_email"]),
       data["auto_send"] === true,
       asNullableString(data["created_at"]),
-      asNullableString(data["updated_at"])
+      asNullableString(data["updated_at"]),
+      toComplianceService(data["service"])
     );
   }
 };
@@ -377,17 +687,17 @@ var ComplianceTaxReportState = {
   ERROR: "error",
   UNKNOWN: "unknown"
 };
-var VALUES2 = Object.values(ComplianceTaxReportState);
+var VALUES3 = Object.values(ComplianceTaxReportState);
 function toComplianceTaxReportState(value) {
   if (typeof value === "string") {
     const normalized = value.trim().toLowerCase();
-    if (VALUES2.includes(normalized)) {
+    if (VALUES3.includes(normalized)) {
       return normalized;
     }
   }
   return ComplianceTaxReportState.UNKNOWN;
 }
-var DESCRIPTIONS2 = {
+var DESCRIPTIONS3 = {
   [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.",
@@ -397,7 +707,7 @@ var DESCRIPTIONS2 = {
   [ComplianceTaxReportState.UNKNOWN]: "Unknown state."
 };
 function describeComplianceTaxReportState(state) {
-  return DESCRIPTIONS2[state];
+  return DESCRIPTIONS3[state];
 }
 
 // src/dto/ComplianceTaxReport.ts
@@ -519,6 +829,31 @@ var ComplianceTaxReportPage = class _ComplianceTaxReportPage {
   }
 };
 
+// src/enums/ComplianceDocumentType.ts
+var ComplianceDocumentType = {
+  INVOICE: "invoice",
+  CREDIT_NOTE: "credit_note",
+  UNKNOWN: "unknown"
+};
+var VALUES4 = Object.values(ComplianceDocumentType);
+function toComplianceDocumentType(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES4.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return ComplianceDocumentType.UNKNOWN;
+}
+var DESCRIPTIONS4 = {
+  [ComplianceDocumentType.INVOICE]: "Commercial invoice.",
+  [ComplianceDocumentType.CREDIT_NOTE]: "Credit note correcting a previously issued invoice.",
+  [ComplianceDocumentType.UNKNOWN]: "Unknown document type."
+};
+function describeComplianceDocumentType(type) {
+  return DESCRIPTIONS4[type];
+}
+
 // src/enums/ComplianceTransactionState.ts
 var ComplianceTransactionState = {
   PENDING: "pending",
@@ -527,17 +862,17 @@ var ComplianceTransactionState = {
   ERROR: "error",
   UNKNOWN: "unknown"
 };
-var VALUES3 = Object.values(ComplianceTransactionState);
+var VALUES5 = Object.values(ComplianceTransactionState);
 function toComplianceTransactionState(value) {
   if (typeof value === "string") {
     const normalized = value.trim().toLowerCase();
-    if (VALUES3.includes(normalized)) {
+    if (VALUES5.includes(normalized)) {
       return normalized;
     }
   }
   return ComplianceTransactionState.UNKNOWN;
 }
-var DESCRIPTIONS3 = {
+var DESCRIPTIONS5 = {
   [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.",
@@ -545,7 +880,7 @@ var DESCRIPTIONS3 = {
   [ComplianceTransactionState.UNKNOWN]: "Unknown state."
 };
 function describeComplianceTransactionState(state) {
-  return DESCRIPTIONS3[state];
+  return DESCRIPTIONS5[state];
 }
 
 // src/enums/ComplianceTransactionType.ts
@@ -557,17 +892,17 @@ var ComplianceTransactionType = {
   CROSSBORDER_INBOUND: "crossborder_inbound",
   UNKNOWN: "unknown"
 };
-var VALUES4 = Object.values(ComplianceTransactionType);
+var VALUES6 = Object.values(ComplianceTransactionType);
 function toComplianceTransactionType(value) {
   if (typeof value === "string") {
     const normalized = value.trim().toLowerCase();
-    if (VALUES4.includes(normalized)) {
+    if (VALUES6.includes(normalized)) {
       return normalized;
     }
   }
   return ComplianceTransactionType.UNKNOWN;
 }
-var DESCRIPTIONS4 = {
+var DESCRIPTIONS6 = {
   [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).",
@@ -576,7 +911,7 @@ var DESCRIPTIONS4 = {
   [ComplianceTransactionType.UNKNOWN]: "Unknown transaction type."
 };
 function describeComplianceTransactionType(type) {
-  return DESCRIPTIONS4[type];
+  return DESCRIPTIONS6[type];
 }
 
 // src/dto/ComplianceTransaction.ts
@@ -594,8 +929,34 @@ function asMoney2(value) {
   if (typeof value === "number" && Number.isFinite(value)) return String(value);
   return "0.00";
 }
+function asNullableNumber2(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "" && Number.isFinite(Number(value))) return Number(value);
+  return null;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function asRecordList(value) {
+  return Array.isArray(value) ? value.filter((row) => asRecord(row) !== null) : [];
+}
+function toInvoiceLines(providerPayload) {
+  const invoice = asRecord(asRecord(providerPayload)?.["invoice"]);
+  return asRecordList(invoice?.["invoice_lines_attributes"]).map((line) => ({
+    description: asString3(line["description"]),
+    quantity: asNullableNumber2(line["quantity"]),
+    price: asMoney2(line["price"]),
+    unit: asNullableNumber2(line["unit"]),
+    taxes: asRecordList(line["taxes_attributes"]).map((tax) => ({
+      name: asString3(tax["name"]),
+      percent: asNullableNumber2(tax["percent"]),
+      category: asNullableString3(tax["category"]),
+      comment: asNullableString3(tax["comment"])
+    }))
+  }));
+}
 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) {
+  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, counterpartyRegisterId = null, counterpartyAddress = null, counterpartyCity = null, counterpartyPostalcode = null, counterpartyEmail = null, buyerReference = null, documentType = ComplianceDocumentType.INVOICE, amendedNumber = null, amendedDate = null, providerState = null, invoiceLines = []) {
     this.id = id;
     this.companyId = companyId;
     this.complianceEnrollmentId = complianceEnrollmentId;
@@ -623,6 +984,17 @@ var ComplianceTransaction = class _ComplianceTransaction {
     this.taxReport = taxReport;
     this.createdAt = createdAt;
     this.updatedAt = updatedAt;
+    this.counterpartyRegisterId = counterpartyRegisterId;
+    this.counterpartyAddress = counterpartyAddress;
+    this.counterpartyCity = counterpartyCity;
+    this.counterpartyPostalcode = counterpartyPostalcode;
+    this.counterpartyEmail = counterpartyEmail;
+    this.buyerReference = buyerReference;
+    this.documentType = documentType;
+    this.amendedNumber = amendedNumber;
+    this.amendedDate = amendedDate;
+    this.providerState = providerState;
+    this.invoiceLines = invoiceLines;
   }
   id;
   companyId;
@@ -651,6 +1023,20 @@ var ComplianceTransaction = class _ComplianceTransaction {
   taxReport;
   createdAt;
   updatedAt;
+  counterpartyRegisterId;
+  counterpartyAddress;
+  counterpartyCity;
+  counterpartyPostalcode;
+  counterpartyEmail;
+  buyerReference;
+  documentType;
+  amendedNumber;
+  amendedDate;
+  providerState;
+  invoiceLines;
+  get isCreditNote() {
+    return this.documentType === ComplianceDocumentType.CREDIT_NOTE;
+  }
   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(
@@ -680,7 +1066,18 @@ var ComplianceTransaction = class _ComplianceTransaction {
       asNullableString3(data["reported_at"]),
       taxReport,
       asNullableString3(data["created_at"]),
-      asNullableString3(data["updated_at"])
+      asNullableString3(data["updated_at"]),
+      asNullableString3(data["counterparty_register_id"]),
+      asNullableString3(data["counterparty_address"]),
+      asNullableString3(data["counterparty_city"]),
+      asNullableString3(data["counterparty_postalcode"]),
+      asNullableString3(data["counterparty_email"]),
+      asNullableString3(data["buyer_reference"]),
+      data["document_type"] === void 0 || data["document_type"] === null ? ComplianceDocumentType.INVOICE : toComplianceDocumentType(data["document_type"]),
+      asNullableString3(data["amended_number"]),
+      asNullableString3(data["amended_date"]),
+      asNullableString3(data["provider_state"]),
+      toInvoiceLines(data["provider_payload"])
     );
   }
 };
@@ -739,10 +1136,134 @@ var ImportResult = class _ImportResult {
   }
 };
 
-// src/dto/RevenueStatistics.ts
+// src/enums/PeppolLookupStatus.ts
+var PeppolLookupStatus = {
+  REACHABLE: "reachable",
+  NOT_REACHABLE: "not_reachable",
+  PENDING: "pending",
+  UNKNOWN: "unknown"
+};
+var VALUES7 = Object.values(PeppolLookupStatus);
+function toPeppolLookupStatus(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES7.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return PeppolLookupStatus.UNKNOWN;
+}
+var DESCRIPTIONS7 = {
+  [PeppolLookupStatus.REACHABLE]: "The participant is registered on Peppol and can receive e-invoices.",
+  [PeppolLookupStatus.NOT_REACHABLE]: "The participant is not registered on Peppol.",
+  [PeppolLookupStatus.PENDING]: "The directory lookup is still resolving \u2014 ask again in a few seconds.",
+  [PeppolLookupStatus.UNKNOWN]: "Unknown lookup status."
+};
+function describePeppolLookupStatus(status) {
+  return DESCRIPTIONS7[status];
+}
+
+// src/dto/PeppolLookupResult.ts
 function asString4(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
 }
+function asNullableString4(value) {
+  return typeof value === "string" ? value : null;
+}
+var PeppolLookupResult = class _PeppolLookupResult {
+  constructor(status, reachable, country, scheme, id, documentTypes, transportTypeCode, checkedAt) {
+    this.status = status;
+    this.reachable = reachable;
+    this.country = country;
+    this.scheme = scheme;
+    this.id = id;
+    this.documentTypes = documentTypes;
+    this.transportTypeCode = transportTypeCode;
+    this.checkedAt = checkedAt;
+  }
+  status;
+  reachable;
+  country;
+  scheme;
+  id;
+  documentTypes;
+  transportTypeCode;
+  checkedAt;
+  /** True while the directory is still resolving — ask again in a few seconds. */
+  get isPending() {
+    return this.status === PeppolLookupStatus.PENDING;
+  }
+  static fromArray(data) {
+    const documentTypes = Array.isArray(data["document_types"]) ? data["document_types"].filter((t) => typeof t === "string") : [];
+    return new _PeppolLookupResult(
+      toPeppolLookupStatus(data["status"]),
+      typeof data["reachable"] === "boolean" ? data["reachable"] : null,
+      asString4(data["country"]),
+      asString4(data["scheme"]),
+      asString4(data["id"]),
+      documentTypes,
+      asNullableString4(data["transport_type_code"]),
+      asNullableString4(data["checked_at"])
+    );
+  }
+};
+
+// src/dto/RegistryCompany.ts
+function asString5(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function asNullableString5(value) {
+  return typeof value === "string" ? value : null;
+}
+var RegistryCompany = class _RegistryCompany {
+  constructor(orgNumber, companyName, organisationForm, vatRegistered, vatNumber, enterpriseRegister, bankrupt, underLiquidation, address, postalcode, city, country) {
+    this.orgNumber = orgNumber;
+    this.companyName = companyName;
+    this.organisationForm = organisationForm;
+    this.vatRegistered = vatRegistered;
+    this.vatNumber = vatNumber;
+    this.enterpriseRegister = enterpriseRegister;
+    this.bankrupt = bankrupt;
+    this.underLiquidation = underLiquidation;
+    this.address = address;
+    this.postalcode = postalcode;
+    this.city = city;
+    this.country = country;
+  }
+  orgNumber;
+  companyName;
+  organisationForm;
+  vatRegistered;
+  vatNumber;
+  enterpriseRegister;
+  bankrupt;
+  underLiquidation;
+  address;
+  postalcode;
+  city;
+  country;
+  static fromArray(data) {
+    return new _RegistryCompany(
+      asString5(data["org_number"]),
+      asString5(data["company_name"]),
+      asNullableString5(data["organisation_form"]),
+      data["vat_registered"] === true,
+      asNullableString5(data["vat_number"]),
+      data["enterprise_register"] === true,
+      data["bankrupt"] === true,
+      data["under_liquidation"] === true,
+      asNullableString5(data["address"]),
+      asNullableString5(data["postalcode"]),
+      asNullableString5(data["city"]),
+      asString5(data["country"])
+    );
+  }
+};
+
+// src/dto/RevenueStatistics.ts
+function asString6(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
 function asNumber4(value) {
   return typeof value === "number" ? value : Number(value ?? 0) || 0;
 }
@@ -792,35 +1313,35 @@ var RevenueStatistics = class _RevenueStatistics {
       typeof data["totals"] === "object" && data["totals"] !== null ? data["totals"] : {}
     );
     const timeSeries = asRecords(data["time_series"]).map((row) => ({
-      bucket: asString4(row["bucket"]),
+      bucket: asString6(row["bucket"]),
       ...toTotals(row)
     }));
     const byType = asRecords(data["by_type"]).map((row) => ({
-      type: asString4(row["type"]),
-      typeLabel: asString4(row["type_label"]),
+      type: asString6(row["type"]),
+      typeLabel: asString6(row["type_label"]),
       count: asNumber4(row["count"]),
       total: asMoney3(row["total"])
     }));
     const byCountry = asRecords(data["by_country"]).map((row) => ({
-      country: asString4(row["country"], "unknown"),
+      country: asString6(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"]),
+      state: asString6(row["state"]),
+      stateLabel: asString6(row["state_label"]),
       count: asNumber4(row["count"]),
       total: asMoney3(row["total"])
     }));
     const byCurrency = asRecords(data["by_currency"]).map((row) => ({
-      currency: asString4(row["currency"]),
+      currency: asString6(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"),
+      asString6(range["date_from"]) || void 0,
+      asString6(range["date_to"]) || void 0,
+      asString6(range["interval"]) || void 0,
+      asString6(data["primary_currency"], "EUR"),
       data["is_multi_currency"] === true,
       totals,
       timeSeries,
@@ -833,10 +1354,10 @@ var RevenueStatistics = class _RevenueStatistics {
 };
 
 // src/dto/SireneLookupResult.ts
-function asString5(value, fallback = "") {
+function asString7(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
 }
-function asNullableString4(value) {
+function asNullableString6(value) {
   return typeof value === "string" ? value : null;
 }
 var SireneLookupResult = class _SireneLookupResult {
@@ -862,21 +1383,21 @@ var SireneLookupResult = class _SireneLookupResult {
   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"])
+      asString7(data["company_name"]),
+      asString7(data["siren"]),
+      asNullableString6(data["siret"]),
+      asNullableString6(data["naf_code"]),
+      asNullableString6(data["naf_full"]),
+      asNullableString6(data["enterprise_size"]),
+      asNullableString6(data["address"]),
+      asNullableString6(data["city"]),
+      asNullableString6(data["postalcode"])
     );
   }
 };
 
 // src/dto/VatRates.ts
-function asString6(value, fallback = "") {
+function asString8(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
 }
 function asNumber5(value) {
@@ -894,12 +1415,12 @@ var VatRates = class _VatRates {
   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"]),
+      category: asString8(row["category"]),
+      labelKey: asString8(row["label_key"]),
+      taxName: asString8(row["tax_name"]),
       requiresVatex: row["requires_vatex"] === true
     }));
-    return new _VatRates(asString6(data["country"]), asString6(data["currency"], "EUR"), rates);
+    return new _VatRates(asString8(data["country"]), asString8(data["currency"], "EUR"), rates);
   }
 };
 
@@ -918,10 +1439,48 @@ var ValidationException = class extends TaxoraException {
   }
 };
 
+// src/support/NorwegianOrgNumber.ts
+var WEIGHTS = [3, 2, 7, 6, 5, 4, 3, 2];
+var NorwegianOrgNumber = {
+  /** Peppol identifier scheme for Norwegian organisation numbers. */
+  PEPPOL_SCHEME: "0192",
+  /**
+   * Strips whitespace, dots, dashes, a "0192:" Peppol scheme prefix, the "NO"
+   * prefix and the "MVA" suffix: "NO 923 609 016 MVA", "923609016MVA" and
+   * "923 609 016" all become "923609016". Does not validate.
+   */
+  normalize(value) {
+    let v = (value ?? "").trim().toUpperCase().replace(/[\s.-]/g, "");
+    if (v.startsWith("0192:")) v = v.slice(5);
+    if (v.startsWith("NO")) v = v.slice(2);
+    if (v.endsWith("MVA")) v = v.slice(0, -3);
+    return v;
+  },
+  /** True when the (normalized) value is 9 digits with a valid mod-11 check digit. */
+  isValid(value) {
+    const digits = NorwegianOrgNumber.normalize(value);
+    if (!/^\d{9}$/.test(digits)) return false;
+    let sum = 0;
+    for (let i = 0; i < WEIGHTS.length; i++) {
+      sum += Number(digits[i]) * WEIGHTS[i];
+    }
+    let check = 11 - sum % 11;
+    if (check === 11) check = 0;
+    return check !== 10 && check === Number(digits[8]);
+  },
+  /** "NO923609016MVA" — the Norwegian VAT number of an MVA-registered entity. Does not validate. */
+  toVatNumber(value) {
+    return `NO${NorwegianOrgNumber.normalize(value)}MVA`;
+  }
+};
+
 // src/endpoints/EReportingEndpoint.ts
 var DATE_REGEX = /^\d{4}-\d{2}-\d{2}$/;
 var NAF_CODE_REGEX = /^\d{2}$/;
+var COUNTRY_REGEX = /^[A-Za-z]{2}$/;
+var PEPPOL_SCHEME_REGEX = /^\d{4}$/;
 var INTERVALS = ["day", "week", "month"];
+var SERVICES = ["e_reporting", "e_invoicing"];
 var ENTERPRISE_SIZES = ["micro", "pme", "eti", "ge"];
 var TYPE_OPERATIONS = ["services", "goods", "mixed"];
 var TRANSACTION_TYPES = [
@@ -932,29 +1491,40 @@ var TRANSACTION_TYPES = [
   "crossborder_inbound"
 ];
 var EReportingEndpoint = 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;
   // ---------------------------------------------------------------------
   // Enrollments
   // ---------------------------------------------------------------------
   /**
    * Create a compliance enrollment and provision the provider account. By
-   * default the DGFiP regime is activated right away; pass `autoActivate: false`
+   * default the country regime is activated right away (France: DGFiP tax
+   * report setting; Norway: Peppol registration); 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
+   * The input shape depends on `country`: omitted/"FR" takes the France input
+   * (unchanged, backwards compatible), "NO" the Norway input — see also the
+   * createNorwayEnrollment() shortcut.
+   *
+   * Errors: 403 (HttpException, body code `service_not_active`) when the company
+   * lacks the requested service; on provider failure 502 (HttpException) — the
+   * enrollment is then persisted in `error_account`/`error_activation` state so
    * provisioning can be retried.
    */
   async createEnrollment(input) {
+    if (this.isNorwayEnrollmentInput(input)) {
+      return this.createEnrollmentFromBody(this.buildNorwayEnrollmentBody(input));
+    }
     this.validateEnrollmentInput(input);
     const body = {
       email: input.email,
@@ -964,6 +1534,7 @@ var EReportingEndpoint = class {
       reporting_start_date: this.formatDate(input.reportingStartDate)
     };
     if (input.country !== void 0) body["country"] = input.country;
+    if (input.service !== void 0) body["service"] = input.service;
     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;
@@ -974,9 +1545,15 @@ var EReportingEndpoint = class {
     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);
+    return this.createEnrollmentFromBody(body);
+  }
+  /**
+   * Enroll the company for Norway e-invoicing (EHF / Peppol BIS 3.0) — shortcut
+   * for createEnrollment({ country: 'NO', ... }). The organisation number is
+   * checked (mod-11) and normalized to 9 digits before sending.
+   */
+  async createNorwayEnrollment(input) {
+    return this.createEnrollment({ ...input, country: "NO" });
   }
   /** Paginated list of the company's enrollments (newest first). `perPage` is capped at 100 server-side. */
   async listEnrollments(page = 1, perPage = 25) {
@@ -1010,6 +1587,72 @@ var EReportingEndpoint = class {
     const data = await this.parseJsonResponse(response);
     return SireneLookupResult.fromArray(data);
   }
+  /**
+   * Look up companies in a national company register — currently Norway
+   * (Brønnøysund Enhetsregisteret). `q` is an organisation number, a "NO…MVA"
+   * VAT number or a company name; an exact number match yields one result.
+   * Ideal for prefilling createNorwayEnrollment() and the buyer fields of an
+   * e-invoice. For France use sireneLookup().
+   *
+   * Errors: 404 (HttpException) when nothing is found, 422 (ValidationException)
+   * on invalid input / unsupported country, 429 (HttpException) when the
+   * per-user rate limit (30/min) is exceeded.
+   */
+  async registryLookup(country, q) {
+    const normalizedCountry = this.normalizeLookupCountry(country);
+    const query = q.trim();
+    if (query === "") {
+      throw new TaxoraException("q must not be empty.");
+    }
+    if (normalizedCountry === "NO") {
+      const digits = NorwegianOrgNumber.normalize(query);
+      if (/^\d{9}$/.test(digits) && !NorwegianOrgNumber.isValid(digits)) {
+        throw new TaxoraException(`Invalid Norwegian organisation number "${query}" (check digit).`);
+      }
+    }
+    const params = new URLSearchParams();
+    params.set("country", normalizedCountry);
+    params.set("q", query);
+    const response = await this.sendRequest("GET", `${this.baseUrl}/compliance/registry-lookup?${params.toString()}`);
+    const data = await this.parseJsonResponse(response);
+    const results = Array.isArray(data["results"]) ? data["results"] : [];
+    return results.filter((row) => typeof row === "object" && row !== null && !Array.isArray(row)).map((row) => RegistryCompany.fromArray(row));
+  }
+  /**
+   * Check whether a participant (typically the buyer) can receive e-invoices
+   * over Peppol. For Norway pass the organisation number (scheme defaults to
+   * "0192"): `reachable === true` means the buyer is registered in ELMA and must
+   * receive an EHF e-invoice. The directory resolves asynchronously —
+   * `status === 'pending'` (`reachable === null`) means ask again in a few
+   * seconds. Free of charge; definite answers are cached for 24h server-side.
+   *
+   * A Norwegian organisation number is checked (mod-11) and normalized before
+   * sending. Errors: 422 (ValidationException) on invalid input, 502
+   * (HttpException) on provider failure.
+   */
+  async peppolLookup(country, id, scheme) {
+    const normalizedCountry = this.normalizeLookupCountry(country);
+    let participantId = id.trim();
+    if (participantId === "") {
+      throw new TaxoraException("id must not be empty.");
+    }
+    if (scheme !== void 0 && !PEPPOL_SCHEME_REGEX.test(scheme)) {
+      throw new TaxoraException('scheme must be a 4-digit Peppol identifier scheme, e.g. "0192".');
+    }
+    if (normalizedCountry === "NO" && (scheme === void 0 || scheme === NorwegianOrgNumber.PEPPOL_SCHEME)) {
+      if (!NorwegianOrgNumber.isValid(participantId)) {
+        throw new TaxoraException(`Invalid Norwegian organisation number "${participantId}".`);
+      }
+      participantId = NorwegianOrgNumber.normalize(participantId);
+    }
+    const params = new URLSearchParams();
+    params.set("country", normalizedCountry);
+    params.set("id", participantId);
+    if (scheme !== void 0) params.set("scheme", scheme);
+    const response = await this.sendRequest("GET", `${this.baseUrl}/compliance/peppol-lookup?${params.toString()}`);
+    const data = await this.parseJsonResponse(response);
+    return PeppolLookupResult.fromArray(data);
+  }
   // ---------------------------------------------------------------------
   // Transactions
   // ---------------------------------------------------------------------
@@ -1033,6 +1676,7 @@ var EReportingEndpoint = class {
     this.validateInvoiceNumber(input.invoiceNumber);
     this.validateInvoiceLines(input.invoiceLines);
     this.validateOptionalCodes(input);
+    this.validateBuyerFields(input);
     const body = {
       compliance_enrollment_id: input.complianceEnrollmentId,
       transaction_type: input.transactionType,
@@ -1048,13 +1692,23 @@ var EReportingEndpoint = class {
     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. */
+  /** Paginated list of the company's transactions (newest invoice date first), filterable by date / state / type / enrollment / country. */
   async listTransactions(filters = {}) {
+    if (filters.complianceEnrollmentId !== void 0) {
+      this.validateId(filters.complianceEnrollmentId, "complianceEnrollmentId");
+    }
+    if (filters.country !== void 0 && !COUNTRY_REGEX.test(filters.country)) {
+      throw new TaxoraException("country must be a 2-character ISO 3166-1 alpha-2 code.");
+    }
     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.complianceEnrollmentId !== void 0) {
+      params.set("compliance_enrollment_id", String(filters.complianceEnrollmentId));
+    }
+    if (filters.country !== void 0) params.set("country", filters.country.toUpperCase());
     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();
@@ -1076,6 +1730,7 @@ var EReportingEndpoint = class {
     if (input.invoiceNumber !== void 0) this.validateInvoiceNumber(input.invoiceNumber);
     if (input.invoiceLines !== void 0) this.validateInvoiceLines(input.invoiceLines);
     this.validateOptionalCodes(input);
+    this.validateBuyerFields(input);
     const body = {};
     if (input.transactionType !== void 0) body["transaction_type"] = input.transactionType;
     if (input.invoiceNumber !== void 0) body["invoice_number"] = input.invoiceNumber;
@@ -1198,6 +1853,14 @@ var EReportingEndpoint = class {
    * returned as HTTP 400 (surfaced as HttpException), not 422.
    */
   async requestEReportingAccess(input = {}) {
+    if (input.service !== void 0) this.validateService(input.service);
+    if (input.countries !== void 0) {
+      input.countries.forEach((country, index) => {
+        if (!COUNTRY_REGEX.test(country)) {
+          throw new TaxoraException(`countries[${index}] must be a 2-character ISO 3166-1 alpha-2 code.`);
+        }
+      });
+    }
     const body = {};
     if (input.name !== void 0) body["name"] = input.name;
     if (input.email !== void 0) body["email"] = input.email;
@@ -1205,6 +1868,8 @@ var EReportingEndpoint = class {
     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;
+    if (input.service !== void 0) body["service"] = input.service;
+    if (input.countries !== void 0) body["countries"] = input.countries.map((c) => c.toUpperCase());
     const response = await this.sendRequest("POST", `${this.baseUrl}/compliance/e-reporting-request`, body);
     await this.parseJsonResponse(response);
   }
@@ -1240,6 +1905,73 @@ var EReportingEndpoint = class {
     if (input.country !== void 0 && input.country.length !== 2) {
       throw new TaxoraException("country must be a 2-character ISO 3166-1 alpha-2 code.");
     }
+    if (input.service !== void 0) this.validateService(input.service);
+  }
+  isNorwayEnrollmentInput(input) {
+    return typeof input.country === "string" && input.country.trim().toUpperCase() === "NO";
+  }
+  /** Validates the Norway input and builds its wire body (org number normalized to 9 digits). */
+  buildNorwayEnrollmentBody(input) {
+    if (typeof input.orgNumber !== "string" || !NorwegianOrgNumber.isValid(input.orgNumber)) {
+      throw new TaxoraException(
+        "orgNumber must be a valid 9-digit Norwegian organisation number (mod-11 check digit)."
+      );
+    }
+    for (const field of ["companyName", "address", "city", "postalcode"]) {
+      if (typeof input[field] !== "string" || input[field].trim() === "") {
+        throw new TaxoraException(`${field} is required for a Norway enrollment.`);
+      }
+    }
+    this.validateEmail(input.email, "email");
+    if (input.service !== void 0) this.validateService(input.service);
+    if (input.legalCountry !== void 0 && !COUNTRY_REGEX.test(input.legalCountry)) {
+      throw new TaxoraException("legalCountry must be a 2-character ISO 3166-1 alpha-2 code.");
+    }
+    const body = {
+      country: "NO",
+      org_number: NorwegianOrgNumber.normalize(input.orgNumber),
+      company_name: input.companyName,
+      address: input.address,
+      city: input.city,
+      postalcode: input.postalcode,
+      email: input.email
+    };
+    if (input.service !== void 0) body["service"] = input.service;
+    if (input.regime !== void 0) body["regime"] = input.regime;
+    if (input.vatNumber !== void 0) body["vat_number"] = input.vatNumber;
+    if (input.province !== void 0) body["province"] = input.province;
+    if (input.vatRegistered !== void 0) body["vat_registered"] = input.vatRegistered;
+    if (input.enterpriseRegister !== void 0) body["enterprise_register"] = input.enterpriseRegister;
+    if (input.reception !== void 0) body["reception"] = input.reception;
+    if (input.legalCountry !== void 0) body["legal_country"] = input.legalCountry.toUpperCase();
+    if (input.reportingStartDate !== void 0) {
+      body["reporting_start_date"] = this.formatDate(input.reportingStartDate);
+    }
+    if (input.autoActivate !== void 0) body["auto_activate"] = input.autoActivate;
+    return body;
+  }
+  async createEnrollmentFromBody(body) {
+    const response = await this.sendRequest("POST", `${this.baseUrl}/compliance/enrollments`, body);
+    const data = await this.parseJsonResponse(response);
+    return ComplianceEnrollment.fromArray(data);
+  }
+  validateService(service) {
+    if (!SERVICES.includes(service)) {
+      throw new TaxoraException(`Invalid service "${String(service)}". Expected one of: ${SERVICES.join(", ")}.`);
+    }
+  }
+  validateEmail(email, name) {
+    if (typeof email !== "string" || email.trim() === "" || !email.includes("@")) {
+      throw new TaxoraException(`${name} must be a valid email address.`);
+    }
+  }
+  /** Lookup routes take a 2-letter country; the API expects it upper-case. */
+  normalizeLookupCountry(country) {
+    const normalized = country.trim().toUpperCase();
+    if (!COUNTRY_REGEX.test(normalized)) {
+      throw new TaxoraException("country must be a 2-character ISO 3166-1 alpha-2 code.");
+    }
+    return normalized;
   }
   validateId(id, name) {
     if (!Number.isInteger(id) || id <= 0) {
@@ -1279,6 +2011,33 @@ var EReportingEndpoint = class {
       throw new TaxoraException("counterpartyCountry must be a 2-character ISO 3166-1 alpha-2 code.");
     }
   }
+  /**
+   * Format checks for the buyer/document fields. Country rules (e.g. the Norway
+   * org number being required) depend on the enrollment and stay server-side;
+   * a register id is only check-digit validated when the buyer is Norwegian.
+   */
+  validateBuyerFields(input) {
+    if (input.counterpartyRegisterId !== void 0) {
+      if (input.counterpartyRegisterId.length > 30) {
+        throw new TaxoraException("counterpartyRegisterId must not exceed 30 characters.");
+      }
+      if (input.counterpartyCountry?.toUpperCase() === "NO" && !NorwegianOrgNumber.isValid(input.counterpartyRegisterId)) {
+        throw new TaxoraException(
+          "counterpartyRegisterId must be a valid 9-digit Norwegian organisation number (mod-11 check digit)."
+        );
+      }
+    }
+    if (input.counterpartyEmail !== void 0) this.validateEmail(input.counterpartyEmail, "counterpartyEmail");
+    if (input.buyerReference !== void 0 && input.buyerReference.length > 100) {
+      throw new TaxoraException("buyerReference must not exceed 100 characters.");
+    }
+    if (input.amendedNumber !== void 0 && input.amendedNumber.length > 50) {
+      throw new TaxoraException("amendedNumber must not exceed 50 characters.");
+    }
+    if (input.extraInfo !== void 0 && input.extraInfo.length > 1e3) {
+      throw new TaxoraException("extraInfo must not exceed 1000 characters.");
+    }
+  }
   // ---------------------------------------------------------------------
   // Body building (camelCase input → snake_case wire format)
   // ---------------------------------------------------------------------
@@ -1315,6 +2074,16 @@ var EReportingEndpoint = class {
     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;
+    if (input.counterpartyRegisterId !== void 0) body["counterparty_register_id"] = input.counterpartyRegisterId;
+    if (input.counterpartyAddress !== void 0) body["counterparty_address"] = input.counterpartyAddress;
+    if (input.counterpartyCity !== void 0) body["counterparty_city"] = input.counterpartyCity;
+    if (input.counterpartyPostalcode !== void 0) body["counterparty_postalcode"] = input.counterpartyPostalcode;
+    if (input.counterpartyEmail !== void 0) body["counterparty_email"] = input.counterpartyEmail;
+    if (input.buyerReference !== void 0) body["buyer_reference"] = input.buyerReference;
+    if (input.isCreditNote !== void 0) body["is_credit_note"] = input.isCreditNote;
+    if (input.amendedNumber !== void 0) body["amended_number"] = input.amendedNumber;
+    if (input.amendedDate !== void 0) body["amended_date"] = this.formatDate(input.amendedDate);
+    if (input.extraInfo !== void 0) body["extra_info"] = input.extraInfo;
   }
   // ---------------------------------------------------------------------
   // HTTP plumbing (kept in sync with SmartEnrichmentEndpoint)
@@ -1335,7 +2104,8 @@ var EReportingEndpoint = class {
   async sendRequest(method, url, body) {
     const options = { headers: this.buildHeaders() };
     if (body) options.body = JSON.stringify(body);
-    return this.httpClient.request(method, url, options);
+    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) {
@@ -1348,16 +2118,22 @@ var EReportingEndpoint = class {
       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")
+      );
     }
     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) {
@@ -1375,7 +2151,13 @@ var EReportingEndpoint = class {
       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")
+      );
     }
   }
   /**
@@ -1419,6 +2201,29 @@ var EReportingEndpoint = class {
   }
 };
 
+// src/enums/SmartEnrichmentMode.ts
+var SmartEnrichmentMode = {
+  DEFAULT: "default",
+  COMPLEX: "complex"
+};
+var VALUES8 = Object.values(SmartEnrichmentMode);
+function toSmartEnrichmentMode(value) {
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (VALUES8.includes(normalized)) {
+      return normalized;
+    }
+  }
+  return void 0;
+}
+var DESCRIPTIONS8 = {
+  [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 DESCRIPTIONS8[mode];
+}
+
 // src/enums/SmartEnrichmentStatus.ts
 var SmartEnrichmentStatus = {
   FOUND: "found",
@@ -1430,17 +2235,17 @@ var SmartEnrichmentStatus = {
   FAILED: "failed",
   UNKNOWN: "unknown"
 };
-var VALUES5 = Object.values(SmartEnrichmentStatus);
+var VALUES9 = Object.values(SmartEnrichmentStatus);
 function toSmartEnrichmentStatus(value) {
   if (typeof value === "string") {
     const normalized = value.trim().toLowerCase();
-    if (VALUES5.includes(normalized)) {
+    if (VALUES9.includes(normalized)) {
       return normalized;
     }
   }
   return SmartEnrichmentStatus.UNKNOWN;
 }
-var DESCRIPTIONS5 = {
+var DESCRIPTIONS9 = {
   [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.",
@@ -1451,12 +2256,12 @@ var DESCRIPTIONS5 = {
   [SmartEnrichmentStatus.UNKNOWN]: "Unknown status."
 };
 function describeSmartEnrichmentStatus(status) {
-  return DESCRIPTIONS5[status];
+  return DESCRIPTIONS9[status];
 }
 
 // src/dto/SmartEnrichmentResource.ts
 var SmartEnrichmentResource = class _SmartEnrichmentResource {
-  constructor(status, vatNumber, vatType, confidence, matchedCompanyName, matchedAddress, country, source) {
+  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;
@@ -1465,6 +2270,9 @@ var SmartEnrichmentResource = class _SmartEnrichmentResource {
     this.matchedAddress = matchedAddress;
     this.country = country;
     this.source = source;
+    this.mode = mode;
+    this.providerVerdicts = providerVerdicts;
+    this.addressQuality = addressQuality;
   }
   status;
   vatNumber;
@@ -1474,6 +2282,9 @@ var SmartEnrichmentResource = class _SmartEnrichmentResource {
   matchedAddress;
   country;
   source;
+  mode;
+  providerVerdicts;
+  addressQuality;
   static fromArray(data) {
     const str = (key) => {
       const v = data[key];
@@ -1483,6 +2294,8 @@ var SmartEnrichmentResource = class _SmartEnrichmentResource {
       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"),
@@ -1491,7 +2304,10 @@ var SmartEnrichmentResource = class _SmartEnrichmentResource {
       str("matchedCompanyName"),
       str("matchedAddress"),
       str("country"),
-      str("source")
+      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() {
@@ -1503,7 +2319,10 @@ var SmartEnrichmentResource = class _SmartEnrichmentResource {
       matchedCompanyName: this.matchedCompanyName ?? null,
       matchedAddress: this.matchedAddress ?? null,
       country: this.country ?? null,
-      source: this.source ?? null
+      source: this.source ?? null,
+      mode: this.mode ?? null,
+      providerVerdicts: this.providerVerdicts,
+      addressQuality: this.addressQuality ?? null
     };
   }
 };
@@ -1655,13 +2474,13 @@ var SmartEnrichmentHistoryPage = class _SmartEnrichmentHistoryPage {
 };
 
 // src/dto/SmartEnrichmentStatistics.ts
-function asString7(value, fallback = "") {
+function asString9(value, fallback = "") {
   return typeof value === "string" ? value : fallback;
 }
 function asNumber6(value) {
   return typeof value === "number" ? value : Number(value ?? 0) || 0;
 }
-function asRecord(value) {
+function asRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function asRecords2(value) {
@@ -1684,32 +2503,32 @@ var SmartEnrichmentStatistics = class _SmartEnrichmentStatistics {
   byOutcome;
   confidenceBuckets;
   static fromArray(data) {
-    const range = asRecord(data["range"]);
-    const totals = asRecord(data["totals"]);
+    const range = asRecord2(data["range"]);
+    const totals = asRecord2(data["totals"]);
     const timeSeries = asRecords2(data["time_series"]).map((row) => ({
-      bucket: asString7(row["bucket"]),
+      bucket: asString9(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"]),
+      source: asString9(row["source"]),
       jobs: asNumber6(row["jobs"]),
       found: asNumber6(row["found"])
     }));
     const byOutcome = asRecords2(data["by_outcome"]).map((row) => ({
-      outcome: asString7(row["outcome"]),
+      outcome: asString9(row["outcome"]),
       count: asNumber6(row["count"])
     }));
     const confidenceBuckets = asRecords2(data["confidence_buckets"]).map((row) => ({
-      bucket: asString7(row["bucket"]),
+      bucket: asString9(row["bucket"]),
       count: asNumber6(row["count"])
     }));
     return new _SmartEnrichmentStatistics(
       {
-        dateFrom: asString7(range["date_from"]),
-        dateTo: asString7(range["date_to"]),
-        interval: asString7(range["interval"])
+        dateFrom: asString9(range["date_from"]),
+        dateTo: asString9(range["date_to"]),
+        interval: asString9(range["interval"])
       },
       {
         jobs: asNumber6(totals["jobs"]),
@@ -1731,16 +2550,18 @@ 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) {
+  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;
   /**
    * Single reverse lookup. Returns a confident result synchronously, or a `processing`
    * job (poll with get(job.jobId) or waitForCompletion(job.jobId)) when deeper resolution
@@ -1755,6 +2576,7 @@ var SmartEnrichmentEndpoint = class {
     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);
@@ -1762,13 +2584,18 @@ var SmartEnrichmentEndpoint = class {
   /**
    * 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) {
+  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 response = await this.sendRequest("POST", `${this.baseUrl}/smart-enrichment/bulk`, { items });
+    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);
   }
@@ -1910,24 +2737,34 @@ var SmartEnrichmentEndpoint = class {
   async sendRequest(method, url, body) {
     const options = { headers: this.buildHeaders() };
     if (body) options.body = JSON.stringify(body);
-    return this.httpClient.request(method, url, options);
+    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.status === 422) {
-      throw new ValidationException("Validation failed", this.parseValidationErrors(responseText));
+      throw new ValidationException(
+        jsonErrorMessage(responseText) ?? "Validation failed",
+        this.parseValidationErrors(responseText)
+      );
     }
     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"]))) {
@@ -1943,19 +2780,28 @@ var SmartEnrichmentEndpoint = class {
   async parseRawJson(response) {
     const responseText = await response.text();
     if (response.status === 422) {
-      throw new ValidationException("Validation failed", this.parseValidationErrors(responseText));
+      throw new ValidationException(
+        jsonErrorMessage(responseText) ?? "Validation failed",
+        this.parseValidationErrors(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")
+      );
     }
     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);
     }
     return parsed;
   }
@@ -1966,10 +2812,19 @@ var SmartEnrichmentEndpoint = class {
   async parseCsvResponse(response) {
     const responseText = await response.text();
     if (response.status === 422) {
-      throw new ValidationException("Validation failed", this.parseValidationErrors(responseText));
+      throw new ValidationException(
+        jsonErrorMessage(responseText) ?? "Validation failed",
+        this.parseValidationErrors(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")
+      );
     }
     return responseText;
   }
@@ -2006,14 +2861,14 @@ var VatState = {
 function getFailedVatStates() {
   return [VatState.INVALID, VatState.FRAUD];
 }
-var DESCRIPTIONS6 = {
+var DESCRIPTIONS10 = {
   [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 DESCRIPTIONS6[state];
+  return DESCRIPTIONS10[state];
 }
 
 // src/dto/CompanyAddress.ts
@@ -2478,16 +3333,18 @@ var VatValidationAddressInput = class _VatValidationAddressInput {
 // src/endpoints/VatEndpoint.ts
 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;
@@ -2495,44 +3352,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();
@@ -2540,16 +3397,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);
@@ -2573,9 +3434,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 = {
@@ -2599,7 +3462,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;
   }
@@ -2614,19 +3483,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"]))) {
@@ -2725,7 +3600,7 @@ var AuthRetryHttpClient = class {
 };
 
 // src/version.ts
-var SDK_VERSION = "1.1.0";
+var SDK_VERSION = "1.3.0";
 
 // src/http/SdkVersionHttpClient.ts
 var SDK_VERSION_HEADER = "X-Taxora-SDK-Version";
@@ -2757,14 +3632,21 @@ var TaxoraClient = class {
     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, versionedClient);
+    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);
-    this.company = new CompanyEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient);
-    this.smartEnrichment = new SmartEnrichmentEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient);
-    this.eReporting = new EReportingEndpoint(this.baseUrl, options.apiKey, tokenStorage, retryClient);
+    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);
   }
 };
 
@@ -2785,6 +3667,125 @@ var Language = {
   ENGLISH: "en",
   GERMAN: "de"
 };
+
+// src/webhooks/WebhookSignature.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var WEBHOOK_SIGNATURE_HEADER = "Taxora-Signature";
+var WEBHOOK_ID_HEADER = "Taxora-Webhook-Id";
+var DEFAULT_WEBHOOK_TOLERANCE_SECONDS = 300;
+var SCHEME = "v1";
+var WebhookSignatureVerificationError = class extends TaxoraException {
+  reason;
+  constructor(message, reason, context = {}) {
+    super(message, { ...context, reason });
+    this.name = "WebhookSignatureVerificationError";
+    this.reason = reason;
+  }
+};
+function parseWebhookSignatureHeader(header) {
+  const value = Array.isArray(header) ? header[0] : header;
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new WebhookSignatureVerificationError(
+      `Missing ${WEBHOOK_SIGNATURE_HEADER} header. Is signing enabled for this webhook endpoint?`,
+      "missing_header"
+    );
+  }
+  let timestamp = null;
+  const signatures = [];
+  for (const part of value.split(",")) {
+    const separator = part.indexOf("=");
+    if (separator === -1) continue;
+    const key = part.slice(0, separator).trim();
+    const val = part.slice(separator + 1).trim();
+    if (key === "t" && /^\d+$/.test(val)) {
+      timestamp = Number(val);
+    } else if (key === SCHEME && /^[0-9a-f]{64}$/i.test(val)) {
+      signatures.push(val.toLowerCase());
+    }
+  }
+  if (timestamp === null || signatures.length === 0) {
+    throw new WebhookSignatureVerificationError(
+      `Malformed ${WEBHOOK_SIGNATURE_HEADER} header \u2014 expected "t=<unix>,v1=<hex>".`,
+      "malformed_header"
+    );
+  }
+  return { timestamp, signatures };
+}
+function computeWebhookSignature(rawBody, timestamp, secret) {
+  return createHmac("sha256", secret).update(`${timestamp}.`).update(toBytes(rawBody)).digest("hex");
+}
+function generateWebhookSignatureHeader(rawBody, secret, timestamp = Math.floor(Date.now() / 1e3)) {
+  const secrets = normalizeSecrets(secret);
+  return [`t=${timestamp}`, ...secrets.map((s) => `${SCHEME}=${computeWebhookSignature(rawBody, timestamp, s)}`)].join(
+    ","
+  );
+}
+function verifyWebhookSignature(rawBody, header, secret, options = {}) {
+  const secrets = normalizeSecrets(secret);
+  const bytes = toBytes(rawBody);
+  const { timestamp, signatures } = parseWebhookSignatureHeader(header);
+  const tolerance = options.tolerance ?? DEFAULT_WEBHOOK_TOLERANCE_SECONDS;
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  if (tolerance > 0 && Math.abs(now - timestamp) > tolerance) {
+    throw new WebhookSignatureVerificationError(
+      `Timestamp outside the tolerance window (${tolerance}s). Possible replay \u2014 or check the server clock.`,
+      "timestamp_outside_tolerance",
+      { timestamp, now, tolerance }
+    );
+  }
+  const received = signatures.map((s) => Buffer.from(s, "hex"));
+  for (const s of secrets) {
+    const expected = Buffer.from(computeWebhookSignature(bytes, timestamp, s), "hex");
+    let matched = false;
+    for (const candidate of received) {
+      if (candidate.length === expected.length && timingSafeEqual(candidate, expected)) {
+        matched = true;
+      }
+    }
+    if (matched) return true;
+  }
+  throw new WebhookSignatureVerificationError(
+    'No signature matches the expected signature for this payload. Make sure you pass the raw request body (not re-serialised JSON) and the full secret including the "whsec_" prefix.',
+    "no_matching_signature"
+  );
+}
+function constructWebhookEvent(rawBody, header, secret, options = {}) {
+  verifyWebhookSignature(rawBody, header, secret, options);
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(toBytes(rawBody)).toString("utf8"));
+  } catch {
+    throw new WebhookSignatureVerificationError("Webhook payload is not valid JSON.", "invalid_payload");
+  }
+  if (typeof parsed !== "object" || parsed === null || typeof parsed.id !== "string" || typeof parsed.event !== "string" || typeof parsed.data !== "object") {
+    throw new WebhookSignatureVerificationError(
+      "Webhook payload does not have the expected { id, event, timestamp, data } shape.",
+      "invalid_payload"
+    );
+  }
+  return parsed;
+}
+function normalizeSecrets(secret) {
+  const list = (typeof secret === "string" ? [secret] : [...secret]).filter(
+    (s) => typeof s === "string" && s !== ""
+  );
+  if (list.length === 0) {
+    throw new WebhookSignatureVerificationError(
+      "No webhook signing secret given. Copy it from the Taxora dashboard (Developer \u2192 Webhooks).",
+      "missing_secret"
+    );
+  }
+  return list;
+}
+function toBytes(rawBody) {
+  if (typeof rawBody === "string") return Buffer.from(rawBody, "utf8");
+  if (rawBody instanceof Uint8Array) return rawBody;
+  if (rawBody instanceof ArrayBuffer) return new Uint8Array(rawBody);
+  throw new WebhookSignatureVerificationError(
+    "Webhook body must be the raw request body (string, Buffer or Uint8Array). It looks like it was already parsed as JSON \u2014 use express.raw() / request.text() instead of a JSON body parser.",
+    "invalid_body"
+  );
+}
 export {
   ApiVersion,
   AuthEndpoint,
@@ -2792,9 +3793,11 @@ export {
   AuthenticationException,
   CompanyAddress,
   CompanyEndpoint,
+  ComplianceDocumentType,
   ComplianceEnrollment,
   ComplianceEnrollmentPage,
   ComplianceEnrollmentStatus,
+  ComplianceService,
   ComplianceTaxReport,
   ComplianceTaxReportPage,
   ComplianceTaxReportState,
@@ -2802,6 +3805,7 @@ export {
   ComplianceTransactionPage,
   ComplianceTransactionState,
   ComplianceTransactionType,
+  DEFAULT_WEBHOOK_TOLERANCE_SECONDS,
   EReportingEndpoint,
   Environment,
   FetchHttpClient,
@@ -2810,8 +3814,13 @@ export {
   InMemoryTokenStorage,
   Language,
   LoginIdentifier,
+  NorwegianOrgNumber,
+  PeppolLookupResult,
+  PeppolLookupStatus,
   ProviderDocument,
   ProviderDocumentLine,
+  RegistryCompany,
+  RetryPolicy,
   RevenueStatistics,
   ScoreBreakdown,
   SireneLookupResult,
@@ -2819,6 +3828,7 @@ export {
   SmartEnrichmentHistoryPage,
   SmartEnrichmentHistoryRow,
   SmartEnrichmentJob,
+  SmartEnrichmentMode,
   SmartEnrichmentResource,
   SmartEnrichmentStatistics,
   SmartEnrichmentStatus,
@@ -2834,18 +3844,35 @@ export {
   VatResource,
   VatState,
   VatValidationAddressInput,
+  WEBHOOK_ID_HEADER,
+  WEBHOOK_SIGNATURE_HEADER,
+  WebhookSignatureVerificationError,
+  computeWebhookSignature,
+  constructWebhookEvent,
+  describeApiError,
+  describeComplianceDocumentType,
   describeComplianceEnrollmentStatus,
+  describeComplianceService,
   describeComplianceTaxReportState,
   describeComplianceTransactionState,
   describeComplianceTransactionType,
+  describePeppolLookupStatus,
+  describeSmartEnrichmentMode,
   describeSmartEnrichmentStatus,
   describeVatState,
+  generateWebhookSignatureHeader,
   getBaseUrl,
   getFailedVatStates,
+  parseWebhookSignatureHeader,
+  toComplianceDocumentType,
   toComplianceEnrollmentStatus,
+  toComplianceService,
   toComplianceTaxReportState,
   toComplianceTransactionState,
   toComplianceTransactionType,
-  toSmartEnrichmentStatus
+  toPeppolLookupStatus,
+  toSmartEnrichmentMode,
+  toSmartEnrichmentStatus,
+  verifyWebhookSignature
 };
 //# sourceMappingURL=index.js.map