@spaceinvoices/react-ui 0.1.1

package/src/components/invoices/create/eslog-validation.test.ts

@@ -0,0 +1,242 @@
+import { describe, expect, it } from "bun:test";
+import type { Entity } from "@/ui/providers/entities-context";
+import { getEntityErrors, getFormFieldErrors, hasEntityErrors, validateEslogForm } from "./eslog-validation";
+
+// Mock entity for testing
+const validEntity: Entity = {
+  id: "ent_test",
+  name: "Test Company d.o.o.",
+  address: "Slovenska cesta 1",
+  address_2: null,
+  post_code: "1000",
+  city: "Ljubljana",
+  state: null,
+  country: "Slovenia",
+  country_code: "SI",
+  currency_code: "EUR",
+  tax_number: "12345678",
+  email: null,
+  is_tax_subject: true,
+  locale: "sl-SI",
+  account_id: "acc_test",
+  environment: "live",
+  settings: {},
+  metadata: {},
+  country_rules: {
+    max_taxes_per_item: 2,
+    features: ["eslog", "furs"],
+  },
+  created_at: new Date().toISOString(),
+  updated_at: new Date().toISOString(),
+};
+
+const validFormValues = {
+  number: "2024-001",
+  date: "2024-01-15",
+  currency_code: "EUR",
+  customer: {
+    name: "Customer Name",
+    address: "Customer Address",
+    post_code: "1000",
+    city: "Ljubljana",
+    country: "Slovenia",
+    country_code: "SI",
+  },
+  items: [
+    {
+      name: "Product 1",
+      quantity: 1,
+      price: 100,
+      taxes: [{ rate: 22 }],
+    },
+  ],
+};
+
+describe("e-SLOG Validation", () => {
+  describe("validateEslogForm", () => {
+    it("should return no errors for valid entity and form values", () => {
+      const errors = validateEslogForm(validFormValues, validEntity);
+      expect(errors).toEqual([]);
+    });
+
+    it("should return empty errors when entity is null", () => {
+      const errors = validateEslogForm(validFormValues, null);
+      expect(errors).toEqual([]);
+    });
+
+    describe("Entity validation", () => {
+      it("should require entity name", () => {
+        const entity = { ...validEntity, name: "" };
+        const errors = validateEslogForm(validFormValues, entity);
+        expect(errors.some((e) => e.field === "entity.name")).toBe(true);
+      });
+
+      it("should require entity address", () => {
+        const entity = { ...validEntity, address: null };
+        const errors = validateEslogForm(validFormValues, entity as Entity);
+        expect(errors.some((e) => e.field === "entity.address")).toBe(true);
+      });
+
+      it("should require entity postal code", () => {
+        const entity = { ...validEntity, post_code: null };
+        const errors = validateEslogForm(validFormValues, entity as Entity);
+        expect(errors.some((e) => e.field === "entity.post_code")).toBe(true);
+      });
+
+      it("should require entity city", () => {
+        const entity = { ...validEntity, city: null };
+        const errors = validateEslogForm(validFormValues, entity as Entity);
+        expect(errors.some((e) => e.field === "entity.city")).toBe(true);
+      });
+
+      it("should require entity country code to be SI", () => {
+        const entity = { ...validEntity, country_code: "AT" };
+        const errors = validateEslogForm(validFormValues, entity);
+        expect(errors.some((e) => e.field === "entity.country_code")).toBe(true);
+      });
+
+      it("should require entity tax number", () => {
+        const entity = { ...validEntity, tax_number: null };
+        const errors = validateEslogForm(validFormValues, entity as Entity);
+        expect(errors.some((e) => e.field === "entity.tax_number")).toBe(true);
+      });
+
+      it("should require 8-digit tax number", () => {
+        const entity = { ...validEntity, tax_number: "123" };
+        const errors = validateEslogForm(validFormValues, entity);
+        expect(errors.some((e) => e.field === "entity.tax_number" && e.message.includes("8 digits"))).toBe(true);
+      });
+    });
+
+    describe("Document validation", () => {
+      it("should require invoice number", () => {
+        const values = { ...validFormValues, number: "" };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "number")).toBe(true);
+      });
+
+      it("should require invoice date", () => {
+        const values = { ...validFormValues, date: undefined };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "date")).toBe(true);
+      });
+
+      it("should require currency code", () => {
+        const values = { ...validFormValues, currency_code: undefined };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "currency_code")).toBe(true);
+      });
+    });
+
+    describe("Customer validation", () => {
+      it("should require customer name when customer data is provided", () => {
+        const values = {
+          ...validFormValues,
+          customer: { address: "Some address", name: "" },
+        };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "customer.name")).toBe(true);
+      });
+
+      it("should not require customer at all", () => {
+        const values = { ...validFormValues, customer: null };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field.startsWith("customer"))).toBe(false);
+      });
+    });
+
+    describe("Line items validation", () => {
+      it("should require at least one line item", () => {
+        const values = { ...validFormValues, items: [] };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "items")).toBe(true);
+      });
+
+      it("should require item name", () => {
+        const values = {
+          ...validFormValues,
+          items: [{ name: "", quantity: 1, price: 100 }],
+        };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "items.0.name")).toBe(true);
+      });
+
+      it("should require quantity > 0", () => {
+        const values = {
+          ...validFormValues,
+          items: [{ name: "Product", quantity: 0, price: 100 }],
+        };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "items.0.quantity")).toBe(true);
+      });
+
+      it("should require price", () => {
+        const values = {
+          ...validFormValues,
+          items: [{ name: "Product", quantity: 1, price: undefined as any }],
+        };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "items.0.price")).toBe(true);
+      });
+
+      it("should validate Slovenian tax rates", () => {
+        const values = {
+          ...validFormValues,
+          items: [{ name: "Product", quantity: 1, price: 100, taxes: [{ rate: 20 }] }],
+        };
+        const errors = validateEslogForm(values, validEntity);
+        expect(errors.some((e) => e.field === "items.0.taxes")).toBe(true);
+      });
+
+      it("should accept valid Slovenian tax rates (22%, 9.5%, 5%, 0%)", () => {
+        const validRates = [22, 9.5, 5, 0];
+        for (const rate of validRates) {
+          const values = {
+            ...validFormValues,
+            items: [{ name: "Product", quantity: 1, price: 100, taxes: [{ rate }] }],
+          };
+          const errors = validateEslogForm(values, validEntity);
+          expect(errors.some((e) => e.field === "items.0.taxes")).toBe(false);
+        }
+      });
+    });
+  });
+
+  describe("hasEntityErrors", () => {
+    it("should return true when entity errors exist", () => {
+      const errors = [{ field: "entity.name", message: "Required" }];
+      expect(hasEntityErrors(errors)).toBe(true);
+    });
+
+    it("should return false when no entity errors", () => {
+      const errors = [{ field: "number", message: "Required" }];
+      expect(hasEntityErrors(errors)).toBe(false);
+    });
+  });
+
+  describe("getEntityErrors", () => {
+    it("should filter entity errors", () => {
+      const errors = [
+        { field: "entity.name", message: "Required" },
+        { field: "number", message: "Required" },
+        { field: "entity.address", message: "Required" },
+      ];
+      const entityErrors = getEntityErrors(errors);
+      expect(entityErrors).toHaveLength(2);
+      expect(entityErrors.every((e) => e.field.startsWith("entity."))).toBe(true);
+    });
+  });
+
+  describe("getFormFieldErrors", () => {
+    it("should filter non-entity errors", () => {
+      const errors = [
+        { field: "entity.name", message: "Required" },
+        { field: "number", message: "Required" },
+        { field: "items.0.name", message: "Required" },
+      ];
+      const formErrors = getFormFieldErrors(errors);
+      expect(formErrors).toHaveLength(2);
+      expect(formErrors.every((e) => !e.field.startsWith("entity."))).toBe(true);
+    });
+  });
+});

package/src/components/invoices/create/eslog-validation.ts

@@ -0,0 +1,208 @@
+/**
+ * Client-side e-SLOG 2.0 validation for invoice creation form
+ *
+ * Validates form data against e-SLOG requirements before submission.
+ * Returns field-specific errors that can be displayed on form elements.
+ */
+
+import type { Entity } from "@/ui/providers/entities-context";
+
+// Valid Slovenian tax rates (%)
+const VALID_SI_TAX_RATES = [22, 9.5, 5, 0];
+
+interface FormValues {
+  number?: string;
+  date?: string;
+  currency_code?: string;
+  customer?: {
+    name?: string;
+    address?: string;
+    post_code?: string;
+    city?: string;
+    country?: string;
+    country_code?: string;
+    tax_number?: string;
+  } | null;
+  items?: Array<{
+    name?: string;
+    quantity?: number;
+    price?: number;
+    taxes?: Array<{ rate?: number }>;
+  }>;
+}
+
+interface ValidationError {
+  field: string;
+  message: string;
+}
+
+/**
+ * Validate form values against e-SLOG 2.0 requirements
+ * Returns array of validation errors with field paths
+ */
+export function validateEslogForm(values: FormValues, entity: Entity | null | undefined): ValidationError[] {
+  const errors: ValidationError[] = [];
+
+  if (!entity) {
+    return errors;
+  }
+
+  // === ISSUER (Entity) VALIDATION ===
+  if (!entity.name?.trim()) {
+    errors.push({
+      field: "entity.name",
+      message: "Entity name is required for e-SLOG. Update in Settings > Company.",
+    });
+  }
+
+  if (!entity.address?.trim()) {
+    errors.push({
+      field: "entity.address",
+      message: "Entity address is required for e-SLOG. Update in Settings > Company.",
+    });
+  }
+
+  if (!entity.post_code?.trim()) {
+    errors.push({
+      field: "entity.post_code",
+      message: "Entity postal code is required for e-SLOG. Update in Settings > Company.",
+    });
+  }
+
+  if (!entity.city?.trim()) {
+    errors.push({
+      field: "entity.city",
+      message: "Entity city is required for e-SLOG. Update in Settings > Company.",
+    });
+  }
+
+  if (entity.country_code !== "SI") {
+    errors.push({
+      field: "entity.country_code",
+      message: "Entity must be from Slovenia (SI) for e-SLOG.",
+    });
+  }
+
+  if (!entity.tax_number?.trim()) {
+    errors.push({
+      field: "entity.tax_number",
+      message: "Entity tax number is required for e-SLOG. Update in Settings > Company.",
+    });
+  } else {
+    const taxNumber = entity.tax_number.replace(/\D/g, "");
+    if (taxNumber.length !== 8) {
+      errors.push({
+        field: "entity.tax_number",
+        message: "Slovenian tax number must be 8 digits.",
+      });
+    }
+  }
+
+  // === DOCUMENT VALIDATION ===
+  if (!values.number?.trim()) {
+    errors.push({
+      field: "number",
+      message: "Invoice number is required for e-SLOG.",
+    });
+  }
+
+  if (!values.date) {
+    errors.push({
+      field: "date",
+      message: "Invoice date is required for e-SLOG.",
+    });
+  }
+
+  if (!values.currency_code) {
+    errors.push({
+      field: "currency_code",
+      message: "Currency is required for e-SLOG.",
+    });
+  } else if (values.currency_code !== "EUR" && entity.currency_code !== "EUR") {
+    // If invoice is not EUR, entity must be EUR so API can convert to _converted fields
+    errors.push({
+      field: "currency_code",
+      message: "Entity currency must be EUR for e-SLOG when invoice uses a different currency.",
+    });
+  }
+
+  // === CUSTOMER VALIDATION ===
+  // Customer is optional, but if provided, name is required
+  if (values.customer && Object.keys(values.customer).length > 0) {
+    const hasAnyCustomerData =
+      values.customer.name || values.customer.address || values.customer.tax_number || values.customer.city;
+
+    if (hasAnyCustomerData && !values.customer.name?.trim()) {
+      errors.push({
+        field: "customer.name",
+        message: "Customer name is required when customer is provided.",
+      });
+    }
+  }
+
+  // === LINE ITEMS VALIDATION ===
+  if (!values.items || values.items.length === 0) {
+    errors.push({
+      field: "items",
+      message: "At least one line item is required for e-SLOG.",
+    });
+  } else {
+    values.items.forEach((item, index) => {
+      if (!item.name?.trim()) {
+        errors.push({
+          field: `items.${index}.name`,
+          message: "Item name is required for e-SLOG.",
+        });
+      }
+
+      if (typeof item.quantity !== "number" || item.quantity <= 0) {
+        errors.push({
+          field: `items.${index}.quantity`,
+          message: "Quantity must be greater than 0.",
+        });
+      }
+
+      if (typeof item.price !== "number") {
+        errors.push({
+          field: `items.${index}.price`,
+          message: "Price is required for e-SLOG.",
+        });
+      }
+
+      // Validate tax rates
+      if (item.taxes && item.taxes.length > 0) {
+        for (const tax of item.taxes) {
+          if (tax.rate !== undefined && !VALID_SI_TAX_RATES.includes(tax.rate)) {
+            errors.push({
+              field: `items.${index}.taxes`,
+              message: `Invalid Slovenian tax rate ${tax.rate}%. Valid: ${VALID_SI_TAX_RATES.join(", ")}%`,
+            });
+          }
+        }
+      }
+    });
+  }
+
+  return errors;
+}
+
+/**
+ * Check if there are any entity-level errors that require settings update
+ */
+export function hasEntityErrors(errors: ValidationError[]): boolean {
+  return errors.some((e) => e.field.startsWith("entity."));
+}
+
+/**
+ * Get entity-level errors for display in a summary
+ */
+export function getEntityErrors(errors: ValidationError[]): ValidationError[] {
+  return errors.filter((e) => e.field.startsWith("entity."));
+}
+
+/**
+ * Get form field errors (non-entity errors)
+ */
+export function getFormFieldErrors(errors: ValidationError[]): ValidationError[] {
+  return errors.filter((e) => !e.field.startsWith("entity."));
+}

package/src/components/invoices/create/locales/de.ts

@@ -0,0 +1,118 @@
+export default {
+  Recipient: "Empfänger",
+  Name: "Name",
+  Details: "Details",
+  Number: "Nummer",
+  "Number format can be changed in settings": "Nummernformat kann in den Einstellungen geändert werden",
+  Date: "Datum",
+  "Pick a date": "Datum auswählen",
+  "Due Date": "Fälligkeitsdatum",
+  "Valid Until": "Gültig bis",
+  Items: "Artikel",
+  "Add item": "Artikel hinzufügen",
+  Save: "Speichern",
+  Update: "Aktualisieren",
+  "Save as Draft": "Als Entwurf speichern",
+  Quantity: "Menge",
+  Price: "Preis",
+  Unit: "Einheit",
+  Discount: "Rabatt",
+  Tax: "Steuer",
+  "Tax rate": "Steuersatz",
+  "Add tax": "Steuer hinzufügen",
+  "Select tax...": "Steuer auswählen...",
+  "Loading...": "Laden...",
+  "No taxes found": "Keine Steuern gefunden",
+  "Add new tax...": "Neue Steuer hinzufügen...",
+  Description: "Beschreibung",
+  "Mark as Paid": "Als bezahlt markieren",
+  Paid: "Bezahlt",
+  "Invoice will be marked as fully paid upon creation": "Rechnung wird bei Erstellung als vollständig bezahlt markiert",
+  "Payment Type": "Zahlungsart",
+  "Select payment type": "Zahlungsart auswählen",
+  Cash: "Bargeld",
+  "Bank Transfer": "Banküberweisung",
+  Card: "Karte",
+  Check: "Scheck",
+  Other: "Andere",
+  // Note field
+  Note: "Notiz",
+  "Insert variable": "Variable einfügen",
+  "Add payment instructions, terms, or other notes...":
+    "Zahlungsanweisungen, Bedingungen oder andere Notizen hinzufügen...",
+  // Payment terms field
+  "Payment Terms": "Zahlungsbedingungen",
+  "Add payment terms...": "Zahlungsbedingungen hinzufügen...",
+  // Smart code categories
+  Entity: "Unternehmen",
+  Document: "Dokument",
+  Customer: "Kunde",
+  // Smart code variable labels
+  "Company name": "Firmenname",
+  "Email address": "E-Mail-Adresse",
+  "Invoice number": "Rechnungsnummer",
+  "Invoice date": "Rechnungsdatum",
+  "Due date": "Fälligkeitsdatum",
+  "Total amount": "Gesamtbetrag",
+  Currency: "Währung",
+  "Select currency": "Währung auswählen",
+  "Customer name": "Kundenname",
+  "Customer email": "Kunden-E-Mail",
+  "Today's date": "Heutiges Datum",
+  "Current year": "Aktuelles Jahr",
+  // Recipient fields
+  "Search or create customer...": "Kunde suchen oder erstellen...",
+  Clear: "Löschen",
+  Address: "Adresse",
+  "Address 2": "Adresse 2",
+  "Post Code": "Postleitzahl",
+  City: "Stadt",
+  State: "Bundesland",
+  Country: "Land",
+  "Tax Number": "Steuernummer",
+  // Discount types
+  "Percentage discount": "Prozentualer Rabatt",
+  "Fixed amount discount": "Fester Rabatt",
+  Percentage: "Prozent",
+  "Fixed amount": "Fester Betrag",
+  // FURS fields
+  "FURS Fiscalization": "FURS Fiskalisierung",
+  "Business Premise": "Geschäftsräume",
+  "Electronic Device": "Elektronisches Gerät",
+  Premise: "Räume",
+  Device: "Gerät",
+  "Select premise": "Räume auswählen",
+  "Select device": "Gerät auswählen",
+  "Skip Fiscalization": "Fiskalisierung überspringen",
+  "Skip fiscalization for this invoice (e.g., bank transfers or unpaid invoices)":
+    "Fiskalisierung für diese Rechnung überspringen (z.B. Banküberweisungen oder unbezahlte Rechnungen)",
+  "Cannot skip fiscalization for cash payments": "Fiskalisierung kann für Barzahlungen nicht übersprungen werden",
+  Skipped: "Übersprungen",
+  Enabled: "Aktiviert",
+  "Click to enable fiscalization": "Klicken Sie, um die Fiskalisierung zu aktivieren",
+  "Fiscally verify": "Steuerlich prüfen",
+  "Click to skip fiscalization for this invoice":
+    "Klicken Sie, um die Fiskalisierung für diese Rechnung zu überspringen",
+  // e-SLOG validation
+  "e-SLOG": "e-SLOG",
+  "Click to skip e-SLOG validation for this invoice":
+    "Klicken Sie, um die e-SLOG-Validierung für diese Rechnung zu überspringen",
+  "Click to enable e-SLOG validation": "Klicken Sie, um die e-SLOG-Validierung zu aktivieren",
+  "e-SLOG Validation Failed": "e-SLOG-Validierung fehlgeschlagen",
+  "The following entity settings need to be updated:":
+    "Die folgenden Unternehmenseinstellungen müssen aktualisiert werden:",
+  // VIES / Reverse Charge
+  "Reverse charge - tax exempt EU B2B sale": "Reverse-Charge - steuerfreier EU B2B-Verkauf",
+  "Taxes disabled": "Steuern deaktiviert",
+  // Gross price support
+  "Gross price": "Bruttopreis",
+  "Net price": "Nettopreis",
+  "Gross price (tax included)": "Bruttopreis (inkl. MwSt.)",
+  "Net price (before tax)": "Nettopreis (exkl. MwSt.)",
+  // Service date
+  "Service Date": "Leistungsdatum",
+  "Single Date": "Datum",
+  "Date Range": "Zeitraum",
+  From: "Von",
+  To: "Bis",
+} as const;

package/src/components/invoices/create/locales/sl.ts

@@ -0,0 +1,114 @@
+export default {
+  Recipient: "Prejemnik",
+  Name: "Ime",
+  Details: "Podrobnosti",
+  Number: "Številka",
+  "Number format can be changed in settings": "Format številke lahko spremenite v nastavitvah",
+  Date: "Datum",
+  "Pick a date": "Izberi datum",
+  "Due Date": "Rok plačila",
+  "Valid Until": "Veljavno do",
+  Items: "Postavke",
+  "Add item": "Dodaj postavko",
+  Save: "Shrani",
+  Update: "Posodobi",
+  "Save as Draft": "Shrani kot osnutek",
+  Quantity: "Količina",
+  Price: "Cena",
+  Unit: "Enota",
+  Discount: "Popust",
+  Tax: "Davek",
+  "Tax rate": "Davčna stopnja",
+  "Add tax": "Dodaj davek",
+  "Select tax...": "Izberi davek...",
+  "Loading...": "Nalaganje...",
+  "No taxes found": "Ni najdenih davkov",
+  "Add new tax...": "Dodaj nov davek...",
+  Description: "Opis",
+  "Mark as Paid": "Označi kot plačano",
+  Paid: "Plačano",
+  "Invoice will be marked as fully paid upon creation": "Račun bo označen kot plačan ob ustvarjanju",
+  "Payment Type": "Vrsta plačila",
+  "Select payment type": "Izberite vrsto plačila",
+  Cash: "Gotovina",
+  "Bank Transfer": "Bančno nakazilo",
+  Card: "Kartica",
+  Check: "Ček",
+  Other: "Drugo",
+  // Note field
+  Note: "Opomba",
+  "Insert variable": "Vstavi spremenljivko",
+  "Add payment instructions, terms, or other notes...": "Dodajte navodila za plačilo, pogoje ali druge opombe...",
+  // Payment terms field
+  "Payment Terms": "Plačilni pogoji",
+  "Add payment terms...": "Dodajte plačilne pogoje...",
+  // Smart code categories
+  Entity: "Podjetje",
+  Document: "Dokument",
+  Customer: "Stranka",
+  // Smart code variable labels
+  "Company name": "Ime podjetja",
+  "Email address": "E-poštni naslov",
+  "Invoice number": "Številka računa",
+  "Invoice date": "Datum računa",
+  "Due date": "Rok plačila",
+  "Total amount": "Skupni znesek",
+  Currency: "Valuta",
+  "Select currency": "Izberi valuto",
+  "Customer name": "Ime stranke",
+  "Customer email": "E-pošta stranke",
+  "Today's date": "Današnji datum",
+  "Current year": "Tekoče leto",
+  // Recipient fields
+  "Search or create customer...": "Išči ali ustvari stranko...",
+  Clear: "Počisti",
+  Address: "Naslov",
+  "Address 2": "Naslov 2",
+  "Post Code": "Poštna številka",
+  City: "Mesto",
+  State: "Regija",
+  Country: "Država",
+  "Tax Number": "Davčna številka",
+  // Discount types
+  "Percentage discount": "Odstotni popust",
+  "Fixed amount discount": "Fiksni popust",
+  Percentage: "Odstotek",
+  "Fixed amount": "Fiksni znesek",
+  // FURS fields
+  "FURS Fiscalization": "FURS davčno potrjevanje",
+  "Business Premise": "Poslovni prostor",
+  "Electronic Device": "Elektronska naprava",
+  Premise: "Prostor",
+  Device: "Naprava",
+  "Select premise": "Izberite prostor",
+  "Select device": "Izberite napravo",
+  "Skip Fiscalization": "Preskoči davčno potrjevanje",
+  "Skip fiscalization for this invoice (e.g., bank transfers or unpaid invoices)":
+    "Preskoči davčno potrjevanje za ta račun (npr. bančna nakazila ali neplačani računi)",
+  "Cannot skip fiscalization for cash payments": "Davčnega potrjevanja ni mogoče preskočiti za gotovinska plačila",
+  Skipped: "Preskočeno",
+  Enabled: "Omogočeno",
+  "Click to enable fiscalization": "Kliknite za omogočanje davčnega potrjevanja",
+  "Fiscally verify": "Davčno potrdi",
+  "Click to skip fiscalization for this invoice": "Kliknite za preskočitev davčnega potrjevanja za ta račun",
+  // e-SLOG validation
+  "e-SLOG": "e-SLOG",
+  "Click to skip e-SLOG validation for this invoice": "Kliknite za preskočitev e-SLOG preverjanja za ta račun",
+  "Click to enable e-SLOG validation": "Kliknite za omogočanje e-SLOG preverjanja",
+  "e-SLOG Validation Failed": "e-SLOG preverjanje ni uspelo",
+  "The following entity settings need to be updated:": "Naslednje nastavitve podjetja je potrebno posodobiti:",
+  // VIES / Reverse Charge
+  "Reverse charge - tax exempt EU B2B sale": "Obrnjena davčna obveznost - davka oproščena EU B2B prodaja",
+  "Taxes disabled": "Davki onemogočeni",
+  // Gross price support
+  "Gross price": "Bruto cena",
+  "Net price": "Neto cena",
+  "Gross price (tax included)": "Bruto cena (z davkom)",
+  "Net price (before tax)": "Neto cena (brez davka)",
+  // Service date
+  "Service Date": "Datum storitve",
+  "Single Date": "Datum",
+  "Date Range": "Obdobje",
+  From: "Od",
+  To: "Do",
+} as const;