@taxora/sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1046 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ApiVersion: () => ApiVersion,
+  AuthEndpoint: () => AuthEndpoint,
+  AuthRetryHttpClient: () => AuthRetryHttpClient,
+  AuthenticationException: () => AuthenticationException,
+  CompanyAddress: () => CompanyAddress,
+  CompanyEndpoint: () => CompanyEndpoint,
+  Environment: () => Environment,
+  FetchHttpClient: () => FetchHttpClient,
+  HttpException: () => HttpException,
+  InMemoryTokenStorage: () => InMemoryTokenStorage,
+  Language: () => Language,
+  LoginIdentifier: () => LoginIdentifier,
+  ProviderDocument: () => ProviderDocument,
+  ProviderDocumentLine: () => ProviderDocumentLine,
+  ScoreBreakdown: () => ScoreBreakdown,
+  TaxoraClient: () => TaxoraClient,
+  TaxoraClientFactory: () => TaxoraClientFactory,
+  TaxoraException: () => TaxoraException,
+  Token: () => Token,
+  ValidationException: () => ValidationException,
+  VatCertificateExport: () => VatCertificateExport,
+  VatCollection: () => VatCollection,
+  VatEndpoint: () => VatEndpoint,
+  VatResource: () => VatResource,
+  VatState: () => VatState,
+  VatValidationAddressInput: () => VatValidationAddressInput,
+  describeVatState: () => describeVatState,
+  getBaseUrl: () => getBaseUrl,
+  getFailedVatStates: () => getFailedVatStates
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/endpoints/AuthEndpoint.ts
+var import_os = require("os");
+
+// src/dto/Token.ts
+var Token = class _Token {
+  constructor(accessToken, tokenType, expiresAt) {
+    this.accessToken = accessToken;
+    this.tokenType = tokenType;
+    this.expiresAt = expiresAt;
+  }
+  accessToken;
+  tokenType;
+  expiresAt;
+  isExpired(bufferSeconds = 15) {
+    return new Date(Date.now() + bufferSeconds * 1e3) >= this.expiresAt;
+  }
+  static fromArray(data) {
+    let accessToken = String(data["access_token"] ?? "");
+    if (accessToken.startsWith("Bearer ")) {
+      accessToken = accessToken.slice(7);
+    }
+    const tokenType = String(data["token_type"] ?? "Bearer");
+    const expiresIn = typeof data["expires_in"] === "number" ? data["expires_in"] : 3600;
+    const expiresAt = new Date(Date.now() + expiresIn * 1e3);
+    return new _Token(accessToken, tokenType, expiresAt);
+  }
+  toArray() {
+    return {
+      access_token: this.accessToken,
+      token_type: this.tokenType,
+      expires_at: this.expiresAt.toISOString()
+    };
+  }
+};
+
+// src/enums/LoginIdentifier.ts
+var LoginIdentifier = {
+  EMAIL: "email",
+  CLIENT_ID: "client_id"
+};
+
+// src/exceptions/TaxoraException.ts
+var TaxoraException = class extends Error {
+  context;
+  constructor(message, context = {}) {
+    super(message);
+    this.name = "TaxoraException";
+    this.context = context;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/exceptions/AuthenticationException.ts
+var AuthenticationException = class extends TaxoraException {
+  statusCode = 401;
+  constructor(message, context = {}) {
+    super(message, context);
+    this.name = "AuthenticationException";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/exceptions/HttpException.ts
+var HttpException = class extends TaxoraException {
+  statusCode;
+  responseBody;
+  constructor(message, statusCode, responseBody, context = {}) {
+    super(message, context);
+    this.name = "HttpException";
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  getStatusCode() {
+    return this.statusCode;
+  }
+  getResponseBody() {
+    return this.responseBody;
+  }
+};
+
+// src/endpoints/AuthEndpoint.ts
+var AuthEndpoint = class {
+  constructor(baseUrl, apiKey, tokenStorage, httpClient) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.tokenStorage = tokenStorage;
+    this.httpClient = httpClient;
+  }
+  baseUrl;
+  apiKey;
+  tokenStorage;
+  httpClient;
+  async login(identifier, password, device, loginIdentifier = LoginIdentifier.EMAIL) {
+    const deviceName = device ?? (0, import_os.hostname)();
+    const body = {
+      identifier: loginIdentifier,
+      password,
+      device_name: deviceName
+    };
+    if (loginIdentifier === LoginIdentifier.CLIENT_ID) {
+      body["client_id"] = identifier;
+    } 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
+      });
+    }
+    if (!response.ok) {
+      throw new HttpException(`HTTP error ${response.status}`, response.status, responseText);
+    }
+    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);
+  }
+  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 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 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);
+    }
+    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 obj["data"];
+    }
+    return obj;
+  }
+};
+
+// src/endpoints/CompanyEndpoint.ts
+var CompanyEndpoint = class {
+  constructor(baseUrl, apiKey, tokenStorage, httpClient) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.tokenStorage = tokenStorage;
+    this.httpClient = httpClient;
+  }
+  baseUrl;
+  apiKey;
+  tokenStorage;
+  httpClient;
+  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}`;
+    }
+    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 obj["data"];
+    }
+    return obj;
+  }
+};
+
+// src/enums/VatState.ts
+var VatState = {
+  VALID: "valid",
+  INVALID: "invalid",
+  FRAUD: "fraud",
+  UNKNOWN: "unknown"
+};
+function getFailedVatStates() {
+  return [VatState.INVALID, VatState.FRAUD];
+}
+var DESCRIPTIONS = {
+  [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];
+}
+
+// src/dto/CompanyAddress.ts
+var CompanyAddress = class _CompanyAddress {
+  fullAddress;
+  name;
+  street;
+  postalCode;
+  city;
+  state;
+  country;
+  raw;
+  constructor(props) {
+    this.name = props.name ?? null;
+    this.street = props.street ?? null;
+    this.postalCode = props.postalCode ?? null;
+    this.city = props.city ?? null;
+    this.state = props.state ?? null;
+    this.country = props.country ?? null;
+    this.raw = props.raw ?? null;
+    this.fullAddress = props.fullAddress ?? this.assembleFullAddress();
+  }
+  assembleFullAddress() {
+    const parts = [this.street, this.postalCode, this.city, this.country].filter(Boolean);
+    return parts.length > 0 ? parts.join(", ") : null;
+  }
+  static from(value) {
+    if (value === null || value === void 0) return null;
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (!trimmed) return null;
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          return _CompanyAddress.fromArray(parsed, trimmed);
+        }
+      } catch {
+      }
+      return new _CompanyAddress({ raw: trimmed });
+    }
+    if (typeof value === "object" && !Array.isArray(value)) {
+      return _CompanyAddress.fromArray(value, null);
+    }
+    return null;
+  }
+  static fromArray(data, raw) {
+    const get = (key) => {
+      const val = data[key] ?? data[key.replace(/_/g, "-")];
+      return typeof val === "string" && val.trim() ? val.trim() : null;
+    };
+    return new _CompanyAddress({
+      fullAddress: get("full_address"),
+      name: get("name"),
+      street: get("street"),
+      postalCode: get("postal_code") ?? get("postalCode"),
+      city: get("city"),
+      state: get("state"),
+      country: get("country"),
+      raw
+    });
+  }
+  toArray() {
+    return {
+      full_address: this.fullAddress,
+      name: this.name,
+      street: this.street,
+      postal_code: this.postalCode,
+      city: this.city,
+      state: this.state,
+      country: this.country
+    };
+  }
+  toString() {
+    return this.fullAddress ?? this.raw ?? "";
+  }
+};
+
+// src/dto/ScoreBreakdown.ts
+var ScoreBreakdown = class _ScoreBreakdown {
+  constructor(stepName, scoreContribution, metadata) {
+    this.stepName = stepName;
+    this.scoreContribution = scoreContribution;
+    this.metadata = metadata;
+  }
+  stepName;
+  scoreContribution;
+  metadata;
+  static fromArray(data) {
+    return new _ScoreBreakdown(
+      typeof data["step_name"] === "string" ? data["step_name"] : "",
+      typeof data["score_contribution"] === "number" ? data["score_contribution"] : 0,
+      data["metadata"] !== null && typeof data["metadata"] === "object" && !Array.isArray(data["metadata"]) ? data["metadata"] : {}
+    );
+  }
+  toArray() {
+    return {
+      step_name: this.stepName,
+      score_contribution: this.scoreContribution,
+      metadata: this.metadata
+    };
+  }
+};
+
+// src/dto/ProviderDocumentLine.ts
+var ProviderDocumentLine = class _ProviderDocumentLine {
+  constructor(id, vatUid, rowNumber, entryIdentifier, reference, meta) {
+    this.id = id;
+    this.vatUid = vatUid;
+    this.rowNumber = rowNumber;
+    this.entryIdentifier = entryIdentifier;
+    this.reference = reference;
+    this.meta = meta;
+  }
+  id;
+  vatUid;
+  rowNumber;
+  entryIdentifier;
+  reference;
+  meta;
+  static fromArray(data) {
+    if (data === null || data === void 0 || typeof data !== "object" || Array.isArray(data)) {
+      return null;
+    }
+    const d = data;
+    return new _ProviderDocumentLine(
+      typeof d["id"] === "number" ? d["id"] : null,
+      typeof d["vat_uid"] === "string" ? d["vat_uid"] : null,
+      typeof d["row_number"] === "number" ? d["row_number"] : null,
+      typeof d["entry_identifier"] === "string" ? d["entry_identifier"] : null,
+      typeof d["reference"] === "string" ? d["reference"] : null,
+      d["meta"] !== null && typeof d["meta"] === "object" && !Array.isArray(d["meta"]) ? d["meta"] : {}
+    );
+  }
+  toArray() {
+    return {
+      id: this.id,
+      vat_uid: this.vatUid,
+      row_number: this.rowNumber,
+      entry_identifier: this.entryIdentifier,
+      reference: this.reference,
+      meta: this.meta
+    };
+  }
+};
+
+// src/dto/ProviderDocument.ts
+var ProviderDocument = class _ProviderDocument {
+  constructor(id, provider, documentType, state, documentDate, mime, size, hash, meta, line) {
+    this.id = id;
+    this.provider = provider;
+    this.documentType = documentType;
+    this.state = state;
+    this.documentDate = documentDate;
+    this.mime = mime;
+    this.size = size;
+    this.hash = hash;
+    this.meta = meta;
+    this.line = line;
+  }
+  id;
+  provider;
+  documentType;
+  state;
+  documentDate;
+  mime;
+  size;
+  hash;
+  meta;
+  line;
+  static fromArray(data) {
+    if (data === null || data === void 0 || typeof data !== "object" || Array.isArray(data)) {
+      return null;
+    }
+    const d = data;
+    const documentDate = typeof d["document_date"] === "string" && d["document_date"] ? new Date(d["document_date"]) : null;
+    return new _ProviderDocument(
+      typeof d["id"] === "number" ? d["id"] : null,
+      typeof d["provider"] === "string" ? d["provider"] : null,
+      typeof d["document_type"] === "string" ? d["document_type"] : null,
+      typeof d["state"] === "string" ? d["state"] : null,
+      documentDate,
+      typeof d["mime"] === "string" ? d["mime"] : null,
+      typeof d["size"] === "number" ? d["size"] : null,
+      typeof d["hash"] === "string" ? d["hash"] : null,
+      d["meta"] !== null && typeof d["meta"] === "object" && !Array.isArray(d["meta"]) ? d["meta"] : {},
+      ProviderDocumentLine.fromArray(d["line"])
+    );
+  }
+  toArray() {
+    return {
+      id: this.id,
+      provider: this.provider,
+      document_type: this.documentType,
+      state: this.state,
+      document_date: this.documentDate?.toISOString() ?? null,
+      mime: this.mime,
+      size: this.size,
+      hash: this.hash,
+      meta: this.meta,
+      line: this.line?.toArray() ?? null
+    };
+  }
+};
+
+// src/dto/VatResource.ts
+var VatResource = class _VatResource {
+  constructor(uuid, vatUid, state, countryCode, companyName, companyAddress, requestedCompanyName, requestedCompanyNameOriginal, requestedInputAddress, checkedAt, score, scoreSource, scoreAttempts, breakdown, environment, provider, usedProviders, providerVatState, providerNote, providerLastCheckedAt, providerDocument) {
+    this.uuid = uuid;
+    this.vatUid = vatUid;
+    this.state = state;
+    this.countryCode = countryCode;
+    this.companyName = companyName;
+    this.companyAddress = companyAddress;
+    this.requestedCompanyName = requestedCompanyName;
+    this.requestedCompanyNameOriginal = requestedCompanyNameOriginal;
+    this.requestedInputAddress = requestedInputAddress;
+    this.checkedAt = checkedAt;
+    this.score = score;
+    this.scoreSource = scoreSource;
+    this.scoreAttempts = scoreAttempts;
+    this.breakdown = breakdown;
+    this.environment = environment;
+    this.provider = provider;
+    this.usedProviders = usedProviders;
+    this.providerVatState = providerVatState;
+    this.providerNote = providerNote;
+    this.providerLastCheckedAt = providerLastCheckedAt;
+    this.providerDocument = providerDocument;
+  }
+  uuid;
+  vatUid;
+  state;
+  countryCode;
+  companyName;
+  companyAddress;
+  requestedCompanyName;
+  requestedCompanyNameOriginal;
+  requestedInputAddress;
+  checkedAt;
+  score;
+  scoreSource;
+  scoreAttempts;
+  breakdown;
+  environment;
+  provider;
+  usedProviders;
+  providerVatState;
+  providerNote;
+  providerLastCheckedAt;
+  providerDocument;
+  static fromArray(data) {
+    const str = (key) => {
+      const v = data[key];
+      return typeof v === "string" ? v : void 0;
+    };
+    const stateRaw = str("state");
+    const state = stateRaw !== void 0 && Object.values(VatState).includes(stateRaw) ? stateRaw : void 0;
+    const checkedAt = str("checked_at") ? new Date(data["checked_at"]) : void 0;
+    const providerLastCheckedAt = str("provider_last_checked_at") ? new Date(data["provider_last_checked_at"]) : void 0;
+    const breakdown = Array.isArray(data["breakdown"]) ? data["breakdown"].map(ScoreBreakdown.fromArray) : void 0;
+    const usedProviders = Array.isArray(data["used_providers"]) ? data["used_providers"].filter((v) => typeof v === "string") : void 0;
+    const scoreAttempts = Array.isArray(data["score_attempts"]) ? data["score_attempts"] : void 0;
+    const requestedInputAddress = data["requested_input_address"] !== null && typeof data["requested_input_address"] === "object" && !Array.isArray(data["requested_input_address"]) ? data["requested_input_address"] : void 0;
+    return new _VatResource(
+      str("uuid"),
+      str("vat_uid"),
+      state,
+      str("country_code"),
+      str("company_name"),
+      CompanyAddress.from(data["company_address"]) ?? void 0,
+      str("requested_company_name"),
+      str("requested_company_name_original"),
+      requestedInputAddress,
+      checkedAt,
+      typeof data["score"] === "number" ? data["score"] : void 0,
+      str("score_source"),
+      scoreAttempts,
+      breakdown,
+      str("environment"),
+      str("provider"),
+      usedProviders,
+      str("provider_vat_state"),
+      str("provider_note"),
+      providerLastCheckedAt,
+      ProviderDocument.fromArray(data["provider_document"]) ?? void 0
+    );
+  }
+  getBackendLink() {
+    if (!this.uuid) return null;
+    if (this.environment === "LIVE") {
+      return `https://app.taxora.io/vat/history/${this.uuid}`;
+    }
+    return `https://app.sandbox.taxora.io/vat/history/${this.uuid}`;
+  }
+  toArray() {
+    return {
+      uuid: this.uuid,
+      vat_uid: this.vatUid,
+      state: this.state,
+      country_code: this.countryCode,
+      company_name: this.companyName,
+      company_address: this.companyAddress?.toArray() ?? null,
+      requested_company_name: this.requestedCompanyName,
+      requested_company_name_original: this.requestedCompanyNameOriginal,
+      requested_input_address: this.requestedInputAddress ?? null,
+      checked_at: this.checkedAt?.toISOString() ?? null,
+      score: this.score ?? null,
+      score_source: this.scoreSource ?? null,
+      score_attempts: this.scoreAttempts ?? null,
+      breakdown: this.breakdown?.map((b) => b.toArray()) ?? null,
+      environment: this.environment ?? null,
+      provider: this.provider ?? null,
+      used_providers: this.usedProviders ?? null,
+      provider_vat_state: this.providerVatState ?? null,
+      provider_note: this.providerNote ?? null,
+      provider_last_checked_at: this.providerLastCheckedAt?.toISOString() ?? null,
+      provider_document: this.providerDocument?.toArray() ?? null
+    };
+  }
+};
+
+// src/dto/VatCollection.ts
+var VatCollection = class _VatCollection {
+  items;
+  self;
+  constructor(items, self) {
+    this.items = items;
+    this.self = self;
+  }
+  static fromResponse(data) {
+    if (Array.isArray(data)) {
+      return new _VatCollection(data.map(VatResource.fromArray));
+    }
+    if (typeof data === "object" && data !== null) {
+      const obj = data;
+      const items = Array.isArray(obj["data"]) ? obj["data"].map(VatResource.fromArray) : [];
+      const self = typeof obj["self"] === "string" ? obj["self"] : void 0;
+      return new _VatCollection(items, self);
+    }
+    return new _VatCollection([]);
+  }
+  [Symbol.iterator]() {
+    return this.items[Symbol.iterator]();
+  }
+  get length() {
+    return this.items.length;
+  }
+  all() {
+    return [...this.items];
+  }
+};
+
+// src/dto/VatCertificateExport.ts
+var VatCertificateExport = class _VatCertificateExport {
+  constructor(exportId, message) {
+    this.exportId = exportId;
+    this.message = message;
+  }
+  exportId;
+  message;
+  static fromArray(data) {
+    return new _VatCertificateExport(
+      typeof data["export_id"] === "string" ? data["export_id"] : "",
+      typeof data["message"] === "string" ? data["message"] : void 0
+    );
+  }
+  toArray() {
+    const result = { export_id: this.exportId };
+    if (this.message !== void 0) result.message = this.message;
+    return result;
+  }
+};
+
+// src/dto/VatValidationAddressInput.ts
+var ALLOWED_KEYS = /* @__PURE__ */ new Set(["address_line_1", "address_line_2", "postal_code", "city", "country_code"]);
+var VatValidationAddressInput = class _VatValidationAddressInput {
+  addressLine1;
+  addressLine2;
+  postalCode;
+  city;
+  countryCode;
+  constructor(props) {
+    if (props.addressLine1 !== void 0 && props.addressLine1.length > 255) {
+      throw new TaxoraException("addressLine1 must not exceed 255 characters");
+    }
+    if (props.addressLine2 !== void 0 && props.addressLine2.length > 255) {
+      throw new TaxoraException("addressLine2 must not exceed 255 characters");
+    }
+    if (props.countryCode !== void 0 && props.countryCode.length !== 2) {
+      throw new TaxoraException("countryCode must be exactly 2 characters (ISO 3166-1 alpha-2)");
+    }
+    this.addressLine1 = props.addressLine1;
+    this.addressLine2 = props.addressLine2;
+    this.postalCode = props.postalCode;
+    this.city = props.city;
+    this.countryCode = props.countryCode;
+  }
+  static fromArray(data) {
+    for (const key of Object.keys(data)) {
+      if (!ALLOWED_KEYS.has(key)) {
+        throw new TaxoraException(`Unsupported field: "${key}". Allowed fields: ${[...ALLOWED_KEYS].join(", ")}`);
+      }
+    }
+    const getString = (key) => {
+      const val = data[key];
+      if (typeof val !== "string") return void 0;
+      const trimmed = val.trim();
+      return trimmed || void 0;
+    };
+    const countryCode = getString("country_code");
+    return new _VatValidationAddressInput({
+      addressLine1: getString("address_line_1"),
+      addressLine2: getString("address_line_2"),
+      postalCode: getString("postal_code"),
+      city: getString("city"),
+      countryCode: countryCode ? countryCode.toUpperCase() : void 0
+    });
+  }
+  toArray() {
+    const result = {};
+    if (this.addressLine1 !== void 0) result["address_line_1"] = this.addressLine1;
+    if (this.addressLine2 !== void 0) result["address_line_2"] = this.addressLine2;
+    if (this.postalCode !== void 0) result["postal_code"] = this.postalCode;
+    if (this.city !== void 0) result["city"] = this.city;
+    if (this.countryCode !== void 0) result["country_code"] = this.countryCode;
+    return result;
+  }
+};
+
+// 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 VatEndpoint = class {
+  constructor(baseUrl, apiKey, tokenStorage, httpClient) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+    this.tokenStorage = tokenStorage;
+    this.httpClient = httpClient;
+  }
+  baseUrl;
+  apiKey;
+  tokenStorage;
+  httpClient;
+  async validate(vatUid, companyName, provider, addressInput) {
+    const body = { vat_uid: vatUid };
+    if (companyName) body["company_name"] = companyName;
+    if (provider) body["source"] = provider;
+    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);
+  }
+  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);
+  }
+  async validateSchema(vatUid) {
+    const body = { vat_uid: vatUid };
+    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);
+  }
+  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);
+  }
+  async search(term, perPage) {
+    const params = new URLSearchParams();
+    if (term) params.set("term", term);
+    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);
+  }
+  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);
+  }
+  async certificatesBulkExport(fromDate, toDate, countries, lang) {
+    return this.exportRequest(`${this.baseUrl}/vat/certificates/bulk-export`, fromDate, toDate, countries, lang);
+  }
+  async certificatesListExport(fromDate, toDate, countries, lang) {
+    return this.exportRequest(`${this.baseUrl}/vat/certificates/list-export`, fromDate, toDate, countries, lang);
+  }
+  async exportRequest(url, fromDate, toDate, countries, lang) {
+    const from = this.formatDate(fromDate);
+    const to = this.formatDate(toDate);
+    const body = { from_date: from, to_date: to };
+    if (countries && countries.length > 0) body["countries"] = countries;
+    if (lang) body["lang"] = lang;
+    const response = await this.sendRequest("POST", url, body);
+    const data = await this.parseJsonResponse(response, [200, 202]);
+    const exportObj = VatCertificateExport.fromArray(data);
+    if (!exportObj.exportId) {
+      throw new TaxoraException("Export response is missing export_id");
+    }
+    return exportObj;
+  }
+  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);
+  }
+  buildHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "x-api-key": this.apiKey
+    };
+    const token = this.tokenStorage.get();
+    if (token) {
+      headers["Authorization"] = `Bearer ${token.accessToken}`;
+    }
+    return headers;
+  }
+  async sendRequest(method, url, body) {
+    const options = { headers: this.buildHeaders() };
+    if (body) options.body = JSON.stringify(body);
+    return this.httpClient.request(method, url, options);
+  }
+  async sendBinaryRequest(method, url) {
+    const headers = this.buildHeaders();
+    delete headers["Content-Type"];
+    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);
+    }
+    return response;
+  }
+  async parseJsonResponse(response, acceptedStatuses = [200]) {
+    const responseText = await response.text();
+    if (response.status === 422) {
+      let errors = {};
+      try {
+        const parsed2 = JSON.parse(responseText);
+        if (parsed2["errors"] !== null && typeof parsed2["errors"] === "object" && !Array.isArray(parsed2["errors"])) {
+          errors = parsed2["errors"];
+        }
+      } catch {
+      }
+      throw new ValidationException("Validation failed", errors);
+    }
+    if (!response.ok && !acceptedStatuses.includes(response.status)) {
+      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" || Array.isArray(obj["data"]))) {
+      return obj["data"];
+    }
+    return obj;
+  }
+  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/enums/Environment.ts
+var Environment = {
+  SANDBOX: "sandbox",
+  PRODUCTION: "production"
+};
+var BASE_URLS = {
+  [Environment.SANDBOX]: "https://sandbox.taxora.io/v1",
+  [Environment.PRODUCTION]: "https://api.taxora.io/v1"
+};
+function getBaseUrl(environment) {
+  return BASE_URLS[environment];
+}
+
+// src/http/FetchHttpClient.ts
+var FetchHttpClient = class {
+  async request(method, url, options = {}) {
+    return fetch(url, { ...options, method });
+  }
+};
+
+// src/http/InMemoryTokenStorage.ts
+var InMemoryTokenStorage = class {
+  token = null;
+  get() {
+    return this.token;
+  }
+  set(token) {
+    this.token = token;
+  }
+  clear() {
+    this.token = null;
+  }
+};
+
+// src/http/AuthRetryHttpClient.ts
+var AUTH_PATH_PATTERN = /\/auth\//;
+var AuthRetryHttpClient = class {
+  constructor(inner, tokenStorage, refreshFn) {
+    this.inner = inner;
+    this.tokenStorage = tokenStorage;
+    this.refreshFn = refreshFn;
+  }
+  inner;
+  tokenStorage;
+  refreshFn;
+  async request(method, url, options) {
+    if (AUTH_PATH_PATTERN.test(url)) {
+      return this.inner.request(method, url, options);
+    }
+    const currentToken = this.tokenStorage.get();
+    if (currentToken?.isExpired()) {
+      await this.refreshFn();
+    }
+    const updatedOptions = this.injectAuthHeader(options);
+    const response = await this.inner.request(method, url, updatedOptions);
+    if (response.status === 401) {
+      await this.refreshFn();
+      const retryOptions = this.injectAuthHeader(options);
+      const retryResponse = await this.inner.request(method, url, retryOptions);
+      if (retryResponse.status === 401) {
+        const body = await retryResponse.text();
+        throw new AuthenticationException("Authentication failed after token refresh", { status: 401, body });
+      }
+      return retryResponse;
+    }
+    return response;
+  }
+  injectAuthHeader(options) {
+    const token = this.tokenStorage.get();
+    if (!token) return options ?? {};
+    const existing = options?.headers ?? {};
+    const headers = { ...existing, Authorization: `Bearer ${token.accessToken}` };
+    return { ...options ?? {}, headers };
+  }
+};
+
+// src/client/TaxoraClient.ts
+var TaxoraClient = class {
+  auth;
+  vat;
+  company;
+  baseUrl;
+  constructor(options) {
+    const environment = options.environment ?? Environment.SANDBOX;
+    const tokenStorage = options.tokenStorage ?? new InMemoryTokenStorage();
+    const httpClient = options.httpClient ?? new FetchHttpClient();
+    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);
+  }
+};
+
+// src/client/TaxoraClientFactory.ts
+var TaxoraClientFactory = class {
+  static create(options) {
+    return new TaxoraClient(options);
+  }
+};
+
+// src/enums/ApiVersion.ts
+var ApiVersion = {
+  V1: "v1"
+};
+
+// src/enums/Language.ts
+var Language = {
+  ENGLISH: "en",
+  GERMAN: "de"
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiVersion,
+  AuthEndpoint,
+  AuthRetryHttpClient,
+  AuthenticationException,
+  CompanyAddress,
+  CompanyEndpoint,
+  Environment,
+  FetchHttpClient,
+  HttpException,
+  InMemoryTokenStorage,
+  Language,
+  LoginIdentifier,
+  ProviderDocument,
+  ProviderDocumentLine,
+  ScoreBreakdown,
+  TaxoraClient,
+  TaxoraClientFactory,
+  TaxoraException,
+  Token,
+  ValidationException,
+  VatCertificateExport,
+  VatCollection,
+  VatEndpoint,
+  VatResource,
+  VatState,
+  VatValidationAddressInput,
+  describeVatState,
+  getBaseUrl,
+  getFailedVatStates
+});
+//# sourceMappingURL=index.cjs.map