invoicehn 0.1.0

data/lib/invoicehn/sequence.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Invoicehn
+  # Allocates correlativos, gap-free and without reuse.
+  #
+  # Art. 10 num. 7 lit. d: "Los ocho dígitos restantes, corresponderán a la
+  # numeración correlativa de la Factura que deberá iniciarse en uno
+  # (00000001)."
+  #
+  # Counters are keyed by the (establecimiento, punto de emisión, tipo de
+  # documento) triple — the "identificador del documento" — because SAR
+  # authorizes a range per emission point and document type (Art. 59), and each
+  # such series advances independently.
+  #
+  # Allocation and persistence happen inside one exclusive file lock, so two
+  # processes issuing at the same moment cannot land on the same number or skip
+  # one.
+  class Sequence
+    attr_reader :config
+
+    def initialize(config = Config.new)
+      @config = config
+    end
+
+    # The number that would be issued next, without consuming it.
+    def peek(identifier)
+      with_lock(shared: true) do
+        counters = read_counters
+        build(identifier, (counters[identifier] || 0) + 1)
+      end
+    end
+
+    def issued_count(identifier)
+      with_lock(shared: true) { read_counters[identifier] || 0 }
+    end
+
+    # Consumes and returns the next correlativo. The block, if given, runs
+    # inside the lock and receives the allocated number — pass the persistence
+    # step in so allocation and recording are one atomic step and a crash cannot
+    # burn a number without producing a document.
+    def allocate(identifier)
+      with_lock do
+        counters = read_counters
+        correlative = build(identifier, (counters[identifier] || 0) + 1)
+
+        result = block_given? ? yield(correlative) : correlative
+
+        counters[identifier] = correlative.sequence
+        write_counters(counters)
+
+        result
+      end
+    end
+
+    # Aligns the counter with an authorization that does not start at 1 — a
+    # successor range continuing the numbering, for instance.
+    def align_to(authorization)
+      with_lock do
+        counters = read_counters
+        current = counters[authorization.identifier] || 0
+        floor = authorization.range_start.sequence - 1
+
+        if current < floor
+          counters[authorization.identifier] = floor
+          write_counters(counters)
+        end
+
+        counters[authorization.identifier]
+      end
+    end
+
+    def counters = with_lock(shared: true) { read_counters }
+
+    private
+
+    def build(identifier, sequence)
+      establishment, emission_point, document_type = identifier.to_s.split("-")
+
+      unless establishment && emission_point && document_type
+        raise ValidationError,
+              "identificador inválido: #{identifier.inspect} (se espera NNN-NNN-NN)"
+      end
+
+      Correlative.new(establishment: establishment, emission_point: emission_point,
+                      document_type: document_type, sequence: sequence)
+    end
+
+    def read_counters
+      path = @config.sequences_path
+      return {} unless File.exist?(path)
+
+      content = File.read(path)
+      return {} if content.strip.empty?
+
+      JSON.parse(content)
+    rescue JSON::ParserError => e
+      raise Error, "contador de correlativos dañado en #{path}: #{e.message}"
+    end
+
+    def write_counters(counters)
+      path = @config.sequences_path
+      FileUtils.mkdir_p(File.dirname(path))
+      tmp = "#{path}.tmp#{Process.pid}"
+      File.write(tmp, "#{JSON.pretty_generate(counters)}\n")
+      File.rename(tmp, path)
+    end
+
+    # flock on a dedicated lock file. The lock file is never truncated, so
+    # holding it costs nothing and it survives as long as the data directory.
+    def with_lock(shared: false)
+      FileUtils.mkdir_p(File.dirname(@config.lock_path))
+
+      File.open(@config.lock_path, File::RDWR | File::CREAT, 0o644) do |lock|
+        lock.flock(shared ? File::LOCK_SH : File::LOCK_EX)
+        begin
+          yield
+        ensure
+          lock.flock(File::LOCK_UN)
+        end
+      end
+    end
+  end
+end

data/lib/invoicehn/spanish_numerals.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Invoicehn
+  # Renders an amount as Spanish words for the "importe total en números y
+  # letras" of Art. 11 num. 1 lit. k).
+  #
+  # The currency name is a parameter, not a constant: a USD invoice must read
+  # DÓLARES. Hard-coding LEMPIRAS would make the document misstate its own
+  # amount.
+  module SpanishNumerals
+    UNITS = %w[
+      CERO UNO DOS TRES CUATRO CINCO SEIS SIETE OCHO NUEVE DIEZ
+      ONCE DOCE TRECE CATORCE QUINCE DIECISÉIS DIECISIETE DIECIOCHO DIECINUEVE
+    ].freeze
+
+    TENS = {
+      20 => "VEINTE", 30 => "TREINTA", 40 => "CUARENTA", 50 => "CINCUENTA",
+      60 => "SESENTA", 70 => "SETENTA", 80 => "OCHENTA", 90 => "NOVENTA"
+    }.freeze
+
+    # 21-29 contract into a single word and carry an accent on 22, 23 and 26.
+    TWENTIES = {
+      21 => "VEINTIUNO", 22 => "VEINTIDÓS", 23 => "VEINTITRÉS", 24 => "VEINTICUATRO",
+      25 => "VEINTICINCO", 26 => "VEINTISÉIS", 27 => "VEINTISIETE", 28 => "VEINTIOCHO",
+      29 => "VEINTINUEVE"
+    }.freeze
+
+    HUNDREDS = {
+      100 => "CIENTO", 200 => "DOSCIENTOS", 300 => "TRESCIENTOS", 400 => "CUATROCIENTOS",
+      500 => "QUINIENTOS", 600 => "SEISCIENTOS", 700 => "SETECIENTOS",
+      800 => "OCHOCIENTOS", 900 => "NOVECIENTOS"
+    }.freeze
+
+    MAX = 999_999_999_999
+
+    module_function
+
+    # Money -> "MIL DOSCIENTOS TREINTA Y CUATRO LEMPIRAS CON 56/100"
+    def money_to_words(money)
+      rounded = money.round_statutory.amount
+      negative = rounded.negative?
+      integer, cents = rounded.abs.to_s("F").split(".")
+      integer = integer.to_i
+      cents = cents.to_s.ljust(2, "0")[0, 2]
+
+      noun = integer == 1 ? singular_of(money.currency) : plural_of(money.currency)
+
+      # "uno" apocopates directly before the noun: un lempira, veintiún
+      # lempiras, ciento un dólares. Appending the raw cardinal would print
+      # "UNO LEMPIRA", which is not Spanish — and this is the line an accountant
+      # reads aloud.
+      words = "#{apocopate(integer_to_words(integer))} #{noun} CON #{cents}/100"
+      negative ? "MENOS #{words}" : words
+    end
+
+    def singular_of(currency) = Money::CURRENCIES.fetch(currency.to_s.upcase)[:singular]
+    def plural_of(currency)   = Money::CURRENCIES.fetch(currency.to_s.upcase)[:plural]
+
+    # Cardinal in the masculine form, which is what both LEMPIRA and DÓLAR take.
+    def integer_to_words(number)
+      number = Integer(number)
+      raise ValidationError, "número negativo" if number.negative?
+      raise ValidationError, "número fuera de rango: #{number}" if number > MAX
+
+      return UNITS[0] if number.zero?
+
+      millions, remainder = number.divmod(1_000_000)
+      parts = []
+      parts << millions_phrase(millions) if millions.positive?
+      parts << below_million(remainder) if remainder.positive?
+      parts.join(" ")
+    end
+
+    def millions_phrase(millions)
+      # "UN MILLÓN", not "UNO MILLÓN" — uno apocopates before a noun.
+      return "UN MILLÓN" if millions == 1
+
+      "#{apocopate(below_million(millions))} MILLONES"
+    end
+
+    def below_million(number)
+      thousands, remainder = number.divmod(1_000)
+      parts = []
+
+      if thousands.positive?
+        # 1000 is "MIL", never "UN MIL".
+        parts << (thousands == 1 ? "MIL" : "#{apocopate(below_thousand(thousands))} MIL")
+      end
+      parts << below_thousand(remainder) if remainder.positive?
+      parts.join(" ")
+    end
+
+    def below_thousand(number)
+      return "" if number.zero?
+      return "CIEN" if number == 100
+
+      hundreds = (number / 100) * 100
+      remainder = number % 100
+      parts = []
+      parts << HUNDREDS[hundreds] if hundreds.positive?
+      parts << below_hundred(remainder) if remainder.positive?
+      parts.join(" ")
+    end
+
+    def below_hundred(number)
+      return "" if number.zero?
+      return UNITS[number] if number < 20
+      return TWENTIES[number] if TWENTIES.key?(number)
+
+      tens = (number / 10) * 10
+      unit = number % 10
+      unit.zero? ? TENS[tens] : "#{TENS[tens]} Y #{UNITS[unit]}"
+    end
+
+    # "UNO" becomes "UN" directly before a noun — MIL, MILLONES, or the currency
+    # name: veintiún mil, un lempira, ciento un dólares.
+    def apocopate(phrase)
+      phrase
+        .sub(/\bVEINTIUNO\z/, "VEINTIÚN")
+        .sub(/\bUNO\z/, "UN")
+    end
+  end
+end

data/lib/invoicehn/storage/json_store.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "date"
+
+module Invoicehn
+  module Storage
+    # Append-only store for issued documents, plus the issuer profile and the
+    # authorizations on file.
+    #
+    # An issued document is never rewritten in place. The one exception is
+    # annulment (Art. 41), which replaces the record with its annulled form —
+    # the correlative stays consumed either way, which is what keeps the series
+    # auditable.
+    class JsonStore
+      attr_reader :config
+
+      def initialize(config = Config.new)
+        @config = config
+      end
+
+      # --- issuer -------------------------------------------------------
+
+      def issuer
+        data = read_json(@config.issuer_path)
+        data && Issuer.from_h(data)
+      end
+
+      def save_issuer(issuer)
+        write_json(@config.issuer_path, issuer.to_h)
+        issuer
+      end
+
+      # --- authorizations ------------------------------------------------
+
+      def authorizations
+        Array(read_json(@config.authorizations_path)).map { |h| Authorization.from_h(h) }
+      end
+
+      # One identifier accumulates authorizations over time: a range is
+      # exhausted, SAR grants a successor, and the old one stays on file as part
+      # of the record.
+      def add_authorization(authorization)
+        existing = authorizations
+        duplicate = existing.find do |a|
+          a.cai == authorization.cai && a.range_start == authorization.range_start
+        end
+        raise ValidationError, "esa autorización ya está registrada" if duplicate
+
+        write_json(@config.authorizations_path, (existing + [authorization]).map(&:to_h))
+        authorization
+      end
+
+      def authorizations_for(identifier)
+        authorizations.select { |a| a.identifier == identifier }
+      end
+
+      # The authorization that should be used next for an identifier: still
+      # current, and with room left in its range.
+      def active_authorization(identifier, next_sequence: nil, on: Date.today)
+        candidates = authorizations_for(identifier).reject { |a| a.expired?(on) }
+        return nil if candidates.empty?
+
+        if next_sequence
+          covering = candidates.select { |a| a.covers?(sequence_to_correlative(identifier, next_sequence)) }
+          return covering.min_by { |a| a.range_start.sequence } if covering.any?
+        end
+
+        candidates.min_by { |a| a.range_start.sequence }
+      end
+
+      # --- documents -----------------------------------------------------
+
+      def save_document(invoice)
+        path = @config.document_path(invoice.correlative, invoice.issue_date)
+        FileUtils.mkdir_p(File.dirname(path))
+
+        if File.exist?(path) && !invoice.annulled?
+          raise ImmutableDocument,
+                "la factura #{invoice.correlative} ya está registrada y no puede modificarse (Art. 41)"
+        end
+
+        write_json(path, invoice.to_h)
+        invoice
+      end
+
+      def find(correlative)
+        correlative = Correlative.parse(correlative.to_s)
+        path = Dir.glob(File.join(@config.documents_dir, "*", "*", "#{correlative}.json")).first
+        raise DocumentNotFound, "no existe la factura #{correlative}" unless path
+
+        Invoice.from_h(read_json(path))
+      end
+
+      def exists?(correlative)
+        Dir.glob(File.join(@config.documents_dir, "*", "*", "#{correlative}.json")).any?
+      end
+
+      # Documents in chronological order, which is the order Art. 43 requires
+      # them to be kept in.
+      def all(from: nil, to: nil)
+        Dir.glob(File.join(@config.documents_dir, "*", "*", "*.json"))
+           .map { |path| Invoice.from_h(read_json(path)) }
+           .select { |inv| within?(inv.issue_date, from, to) }
+           .sort_by { |inv| [inv.issue_date, inv.correlative.to_s] }
+      end
+
+      # --- settings ------------------------------------------------------
+
+      def settings = read_json(@config.settings_path) || {}
+
+      def save_settings(hash)
+        write_json(@config.settings_path, settings.merge(hash))
+      end
+
+      private
+
+      def sequence_to_correlative(identifier, sequence)
+        establishment, emission_point, document_type = identifier.split("-")
+        Correlative.new(establishment: establishment, emission_point: emission_point,
+                        document_type: document_type, sequence: sequence)
+      end
+
+      def within?(date, from, to)
+        return false if from && date < from
+        return false if to && date > to
+
+        true
+      end
+
+      def read_json(path)
+        return nil unless File.exist?(path)
+
+        content = File.read(path)
+        return nil if content.strip.empty?
+
+        JSON.parse(content)
+      rescue JSON::ParserError => e
+        raise Error, "archivo dañado en #{path}: #{e.message}"
+      end
+
+      # Written to a temporary file and renamed, so an interrupted write cannot
+      # leave a half-written fiscal record behind.
+      def write_json(path, data)
+        FileUtils.mkdir_p(File.dirname(path))
+        tmp = "#{path}.tmp#{Process.pid}"
+        File.write(tmp, "#{JSON.pretty_generate(data)}\n")
+        File.rename(tmp, path)
+        data
+      end
+    end
+  end
+end

data/lib/invoicehn/tax_summary.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Invoicehn
+  # The per-rate breakdown an invoice must display.
+  #
+  # Art. 11 num. 1 requires:
+  #   g) "Discriminación de los valores exentos, exonerados y de los gravados
+  #      con alícuota cero, cuando corresponda"
+  #   h) "Subtotales sujetos a los impuestos discriminados por tarifa o alícuota"
+  #   i) "Discriminación de los impuestos por tarifa o alícuota"
+  #   l) "Discriminación de los descuentos y rebajas otorgados" (Acuerdo 725-2018)
+  #
+  # Acuerdo 725-2018 also added Art. 10 num. 10, "Descuentos y rebajas
+  # otorgados", to the *format* requirements. That makes the discounts line part
+  # of the invoice layout rather than something shown only when a discount
+  # exists — so #discount is always available and the renderers always print it,
+  # zero or not.
+  #
+  # ISV is computed on the summed base per rate and rounded once, rather than
+  # rounded per line and then summed. The norm does not settle the question —
+  # Ley del ISV Art. 9 speaks of the charge "sobre el precio del artículo
+  # vendido o servicio prestado", which reads per item, while Art. 11 lit. h/i
+  # require the invoice to *display* a subtotal and a tax per rate. Rounding
+  # once per rate is what keeps those printed figures consistent: rounding each
+  # line and summing can produce a tax total that does not equal the printed
+  # rate times the printed subtotal, and that discrepancy is exactly what an
+  # auditor would question. The choice is recorded here because it is a reading
+  # of an open point, not a settled rule.
+  class TaxSummary
+    # One row of the breakdown: everything the document must show for a single
+    # tax treatment.
+    Bucket = Struct.new(:treatment, :gross, :discount, :base, :isv, keyword_init: true) do
+      def total = base + isv
+      def empty? = gross.zero? && discount.zero?
+      def to_s = "#{treatment}: base #{base}, ISV #{isv}"
+
+      def to_h
+        {
+          "treatment" => treatment.key.to_s,
+          "label" => treatment.label,
+          "rate" => treatment.rate.to_s("F"),
+          "gross" => gross.to_h,
+          "discount" => discount.to_h,
+          "base" => base.to_h,
+          "isv" => isv.to_h
+        }
+      end
+    end
+
+    attr_reader :currency, :buckets
+
+    def initialize(line_items, currency: "HNL")
+      @currency = currency
+      @buckets = build_buckets(Array(line_items))
+      freeze
+    end
+
+    # Only the treatments actually present, in the order the law lists them
+    # (exento, exonerado, gravado 0%, then the taxed rates).
+    def present_buckets = @buckets.reject(&:empty?)
+
+    def bucket_for(treatment)
+      key = TaxTreatment.fetch(treatment).key
+      @buckets.find { |b| b.treatment.key == key }
+    end
+
+    def gross    = sum_of(:gross)
+    def discount = sum_of(:discount)
+
+    # The sum of all bases, taxed and untaxed alike — the invoice's subtotal
+    # after discounts and before ISV.
+    def subtotal = sum_of(:base)
+
+    def isv_total = sum_of(:isv)
+
+    def total = subtotal + isv_total
+
+    # Art. 11 num. 3: "Para respaldar el crédito fiscal en los casos que la
+    # factura sustente ventas exentas y gravadas, se reconocerán únicamente las
+    # ventas gravadas." This is the portion of the invoice that supports the
+    # buyer's crédito fiscal.
+    def credito_fiscal_base
+      Money.sum(taxed_buckets.map(&:base), currency: @currency)
+    end
+
+    def taxed_buckets = present_buckets.select { |b| b.treatment.taxed? }
+    def untaxed_buckets = present_buckets.reject { |b| b.treatment.taxed? }
+
+    # True when the invoice mixes taxed and untaxed supplies, which is the
+    # condition Art. 11 num. 3 addresses.
+    def mixed_supply?
+      taxed_buckets.any? && untaxed_buckets.any?
+    end
+
+    def to_h
+      {
+        "currency" => @currency,
+        "buckets" => present_buckets.map(&:to_h),
+        "gross" => gross.to_h,
+        "discount" => discount.to_h,
+        "subtotal" => subtotal.to_h,
+        "isv_total" => isv_total.to_h,
+        "total" => total.to_h
+      }
+    end
+
+    private
+
+    def build_buckets(line_items)
+      TaxTreatment.all.map do |treatment|
+        lines = line_items.select { |item| item.treatment == treatment }
+
+        gross    = Money.sum(lines.map(&:gross), currency: @currency).round_statutory
+        discount = Money.sum(lines.map(&:discount), currency: @currency).round_statutory
+
+        # Rounded once here, then taxed — so the printed ISV equals the printed
+        # rate applied to the printed base.
+        base = Money.sum(lines.map(&:taxable_base), currency: @currency).round_statutory
+        isv  = (base * treatment.rate).round_statutory
+
+        Bucket.new(treatment: treatment, gross: gross, discount: discount, base: base, isv: isv).freeze
+      end.freeze
+    end
+
+    def sum_of(field)
+      Money.sum(@buckets.map { |b| b.public_send(field) }, currency: @currency)
+    end
+  end
+end

data/lib/invoicehn/tax_treatment.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+module Invoicehn
+  # How a line is treated for Impuesto Sobre Ventas.
+  #
+  # Art. 11 num. 1 lit. g) requires "Discriminación de los valores exentos,
+  # exonerados y de los gravados con alícuota cero", and lit. h) and i) require
+  # subtotals and taxes broken out "por tarifa o alícuota". Three of these
+  # categories yield no tax but must still be told apart on the face of the
+  # document, so the treatment is modelled as an identity rather than as a bare
+  # rate.
+  #
+  # Rates come from Decreto 278-2013 Art. 16 (La Gaceta 33,316, in force
+  # 1 January 2014), which reformed Art. 6 of the Ley del Impuesto Sobre Ventas:
+  # a general rate of 15% and 18% on "las bebidas alcohólicas, cerveza y
+  # cigarrillos al igual que los boletos aéreos de clase ejecutiva".
+  class TaxTreatment
+    include Comparable
+
+    attr_reader :key, :rate, :label
+
+    def initialize(key, rate, label, order)
+      @key = key.to_sym
+      @rate = rate
+      @label = label
+      @order = order
+      freeze
+    end
+
+    # No tax applies — the good or service is outside the tax's reach
+    # (Ley del ISV Art. 15).
+    EXENTO = new(:exento, BigDecimal("0"), "Exento", 0)
+
+    # Taxable in principle, but the purchaser holds an exoneration. Art. 10
+    # num. 8 and Art. 11 num. 4 require the exoneration's supporting numbers on
+    # the invoice.
+    EXONERADO = new(:exonerado, BigDecimal("0"), "Exonerado", 1)
+
+    # Taxed at zero. Art. 12: "En caso de exportaciones con mercancías gravadas,
+    # por concepto del Impuesto Sobre Ventas, los Obligados Tributarios deben
+    # extender la Factura con tasa cero."
+    GRAVADO_0 = new(:gravado_0, BigDecimal("0"), "Gravado 0%", 2)
+
+    # The general rate.
+    GRAVADO_15 = new(:gravado_15, BigDecimal("0.15"), "Gravado 15%", 3)
+
+    # The special rate. Which goods fall here is ambiguously drafted across
+    # sources — the decree names only "clase ejecutiva" for air tickets while
+    # the Art. 6 enumeration it amends adds "otros productos elaborados de
+    # tabaco". Deciding whether a given product qualifies is the operator's
+    # call; this library only computes once that call is made.
+    GRAVADO_18 = new(:gravado_18, BigDecimal("0.18"), "Gravado 18%", 4)
+
+    ALL = {
+      exento: EXENTO,
+      exonerado: EXONERADO,
+      gravado_0: GRAVADO_0,
+      gravado_15: GRAVADO_15,
+      gravado_18: GRAVADO_18
+    }.freeze
+
+    GENERAL_RATE = BigDecimal("0.15")
+    SPECIAL_RATE = BigDecimal("0.18")
+
+    class << self
+      def fetch(key)
+        return key if key.is_a?(TaxTreatment)
+
+        ALL.fetch(key.to_s.to_sym) do
+          raise ValidationError,
+                "tratamiento fiscal desconocido: #{key.inspect} (válidos: #{ALL.keys.join(", ")})"
+        end
+      end
+
+      def all = ALL.values
+
+      # The categories that must be shown separately even though they carry no
+      # tax (Art. 11 num. 1 lit. g).
+      def untaxed = [EXENTO, EXONERADO, GRAVADO_0]
+
+      def taxed = [GRAVADO_15, GRAVADO_18]
+    end
+
+    def taxed? = @rate.positive?
+    def untaxed? = !taxed?
+    def exonerado? = @key == :exonerado
+    def exento? = @key == :exento
+
+    # 15% renders as "15%", not "15.0%".
+    def rate_percent = (@rate * 100).to_i
+
+    def to_s = @label
+    def to_sym = @key
+    def inspect = "#<Invoicehn::TaxTreatment #{@key}>"
+
+    def <=>(other) = other.is_a?(self.class) ? @order <=> other.instance_variable_get(:@order) : nil
+
+    def ==(other) = other.is_a?(self.class) && other.key == @key
+    alias eql? ==
+
+    def hash = @key.hash
+
+    # The five categories above are the complete set the law recognises; a
+    # sixth cannot be invented at runtime.
+    private_class_method :new
+  end
+end

data/lib/invoicehn/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Invoicehn
+  VERSION = "0.1.0"
+end

data/lib/invoicehn.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "invoicehn/version"
+require_relative "invoicehn/errors"
+require_relative "invoicehn/locale"
+require_relative "invoicehn/money"
+require_relative "invoicehn/spanish_numerals"
+require_relative "invoicehn/rtn"
+require_relative "invoicehn/correlative"
+require_relative "invoicehn/tax_treatment"
+require_relative "invoicehn/line_item"
+require_relative "invoicehn/tax_summary"
+require_relative "invoicehn/issuer"
+require_relative "invoicehn/customer"
+require_relative "invoicehn/authorization"
+require_relative "invoicehn/exchange_rate"
+require_relative "invoicehn/compliance/violation"
+require_relative "invoicehn/compliance/validator"
+require_relative "invoicehn/invoice"
+require_relative "invoicehn/config"
+require_relative "invoicehn/storage/json_store"
+require_relative "invoicehn/sequence"
+require_relative "invoicehn/ledger"
+require_relative "invoicehn/issuance"
+require_relative "invoicehn/renderers/text"
+require_relative "invoicehn/renderers/json"
+require_relative "invoicehn/renderers/pdf"
+
+# Facturación electrónica/computarizada para Honduras conforme al Reglamento del
+# Régimen de Facturación (Acuerdo 481-2017 y sus reformas 609-2017, 725-2018 y
+# 817-2018).
+#
+# This library enforces *document content* compliance. It cannot confer
+# authorization: registering in the Régimen de Facturación (Art. 45), enrolling
+# as autoimpresor (Art. 47), filing the Declaración Jurada for a sistema
+# computarizado (Art. 53), and obtaining the CAI, authorized range and fecha
+# límite de emisión (Arts. 59-61) all remain the operator's obligations before
+# any document produced here is valid.
+module Invoicehn
+end