enel-ruby-sdk 0.1.2

data/lib/enel_x/memory_cache.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EnelX
+  # Default token cache: same read/write/delete contract as ActiveSupport::Cache.
+  class MemoryCache
+    def initialize
+      @entries = {}
+      @mutex = Mutex.new
+    end
+
+    def read(key)
+      @mutex.synchronize do
+        value, expires_at = @entries[key]
+        return value if value && (expires_at.nil? || expires_at > Time.now)
+
+        @entries.delete(key)
+        nil
+      end
+    end
+
+    def write(key, value, expires_in: nil)
+      @mutex.synchronize do
+        @entries[key] = [value, expires_in && (Time.now + expires_in)]
+      end
+      value
+    end
+
+    def delete(key)
+      @mutex.synchronize { @entries.delete(key)&.first }
+    end
+  end
+end

data/lib/enel_x/record.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'reference/document_state'
+require_relative 'reference/occurrence'
+
+module EnelX
+  # Item of a history query (PDF 5.6 to 5.10). Attributes are the lowercase keys of the
+  # PDF; null, absent and empty text become nil. Dates and numbers keep the text the API
+  # sent, because the PDF does not specify their format.
+  module Record
+    # Class-level builder: keys are matched ignoring case (novaUC => novauc).
+    module Builder
+      def from_hash(hash)
+        lowered = hash.to_h { |key, value| [key.to_s.downcase, value] }
+        new(**members.to_h { |name| [name, Record.clean(lowered[name.to_s])] })
+      end
+    end
+
+    # Unknown codes still yield an object that keeps the original code.
+    module OccurrenceReader
+      def occurrence
+        Reference::Occurrence.fetch(codocorr) if codocorr
+      end
+    end
+
+    # The raw value stays available in #estadodocumento.
+    module DocumentStateReader
+      def document_state
+        Reference::DocumentState.from(estadodocumento)
+      end
+    end
+
+    module_function
+
+    def define(*members)
+      klass = Class.new(Struct.new(*members, keyword_init: true))
+      klass.extend(Builder)
+      klass.include(OccurrenceReader) if members.include?(:codocorr)
+      klass.include(DocumentStateReader) if members.include?(:estadodocumento)
+      klass
+    end
+
+    def clean(value)
+      return nil if value.nil?
+
+      value.is_a?(String) && value.strip.empty? ? nil : value
+    end
+  end
+
+  SUBSCRIPTION_FIELDS = %i[
+    empresaparc codproduto numerocliente dvnumerocliente dataadesao datacancelamento
+    estado dataprocessamento codcanalvenda usuarioadesao numeroclienteempresaparceira
+    usuariocancelamento obscancelamento quantparcelas parcelasfat headerpartnercode
+    valor novauc
+  ].freeze
+  REQUEST_FIELDS = %i[
+    numerocliente dataocorrencia dvnumerocliente empresaparc codproduto empresa codocorr
+    valor numparcelas referencia datavencimento datapagamento lotefaturamento
+    numeroclienteemppar databaixapagamento codcanalvenda descricaoretorno
+    correlativodocumento headerpartnercode novauc
+  ].freeze
+  COLLECTION_FIELDS = %i[
+    estadodocumento numerocliente dvnumerocliente dataocorrencia valor numparcelas
+    referencia datavencimento datapagamento lotefaturamento numeroclienteemppar
+    codproduto empresaparc databaixapagamento codcanalvenda correlativodocumento
+    headerpartnercode novauc
+  ].freeze
+  # novauc is always empty in this query (PDF 5.10.3).
+  MOVEMENT_FIELDS = %i[
+    numerocliente dvnumerocliente codocorr dataocorrencia valorparcela numparcelas
+    codproduto empresaparc datarecebimento headerpartnercode status novauc
+  ].freeze
+
+  Subscription = Record.define(*SUBSCRIPTION_FIELDS)
+  RequestHistoryItem = Record.define(*REQUEST_FIELDS)
+  InvoiceHistoryItem = Record.define(*(REQUEST_FIELDS + [:estadodocumento]))
+  Collection = Record.define(*COLLECTION_FIELDS)
+  Movement = Record.define(*MOVEMENT_FIELDS)
+end

data/lib/enel_x/reference/distributor.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module EnelX
+  module Reference
+    # Distributors accepted by the API (PDF 5.2.2 LegalEntity and 5.3.2 empresa).
+    class Distributor < Data.define(:code, :name, :state, :legal_entity)
+      ALL = [
+        new('2003', 'Ceará', 'CE', 'EXBRA_SA_Fortaleza_CE'),
+        new('2005', 'Rio de Janeiro', 'RJ', 'EXBRA_SA_Rio_de_Janeiro_RJ'),
+        new('MT10', 'São Paulo', 'SP', 'EXBRA_SA_Paulo_SP'),
+      ].freeze
+
+      class << self
+        def all = ALL
+
+        def find_by_code(code)
+          ALL.find { |item| item.code == code.to_s }
+        end
+
+        def find_by_state(state)
+          ALL.find { |item| item.state.casecmp?(state.to_s) }
+        end
+
+        def find_by_legal_entity(legal_entity)
+          ALL.find { |item| item.legal_entity == legal_entity.to_s }
+        end
+      end
+    end
+  end
+end

data/lib/enel_x/reference/document_state.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module EnelX
+  module Reference
+    # EstadoDocumento values of ConsultaFaturamento (PDF 7.4).
+    module DocumentState
+      VALUES = {
+        'S' => :paid, # Fatura Paga
+        'N' => :open, # Fatura em Aberto
+        'C' => :canceled, # Fatura Cancelada
+      }.freeze
+
+      module_function
+
+      def from(value)
+        VALUES.fetch(value.to_s.strip.upcase, :unknown)
+      end
+    end
+  end
+end

data/lib/enel_x/reference/occurrence.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+# rubocop:disable Layout/LineLength -- tables copied from PDF 7.2
+
+module EnelX
+  module Reference
+    # Reason attached to occurrence 909 (second table of PDF 7.2).
+    CancellationReason = Data.define(:code, :description, :automatic, :note) do
+      def automatic? = automatic
+    end
+
+    # Codes the Enel X returns to the partner (PDF 7.2). Read-only table: it does not
+    # decide anything for the consumer.
+    class Occurrence < Data.define(:code, :description, :ok, :legacy_code, :note, :stage)
+      STAGES = {
+        intake: %w[996 997], audit: %w[998 999],
+        billing: %w[901 902 903 904 905 907 908 909 910 913 914 915 916 917 918 920]
+      }.freeze
+
+      ROWS = [
+        ['901', 'Recebido o Pagamento do produto (arrecadação)', true, '11',
+         'Informe de arrecadação da fatura.'],
+        ['902', 'Inclusão de Cobrança na fatura (faturamento)', true, '12',
+         'Informe de faturamento da cobrança'],
+        ['903', 'Cancelamento de débito após faturamento', false, '14 / 19',
+         'Retirada do valor da conta do cliente, ocorre quando o cliente realiza um ' \
+         'refaturamento retirando um produto da conta'],
+        ['904', 'Ajuste na fatura de energia', true, '15',
+         'Ocorreu um ajuste no faturamento do cliente na distribuidora'],
+        ['905', 'Cliente não faturado / em estado de corte', false, '18',
+         'Informa que o cliente não foi faturado, devido o mesmo está sem fornecimento ' \
+         'no momento do faturamento. No mês seguinte será realizada a nova tentativa ' \
+         'de faturamento'],
+        ['907', 'Crédito por Devolução', true, '13/34',
+         'Inclusão de valor de crédito a título de devolução na fatura'],
+        ['908', 'Cancelamento de faturamento pendente', false, nil,
+         'Cancelamento de uma fatura que que ainda não havia sido emita na distribuidora'],
+        ['909', 'Cancelamento', true, nil,
+         'Para cancelamentos também é enviado a razão do cancelamento conforme tabela abaixo'],
+        ['910', 'Cliente inexistente', false, '36', 'Retorna quando cliente não existe'],
+        ['913', 'Não incluído - Cliente não está ativo no sistema da distribuidora.', false,
+         '06', 'A operação não foi efetuada devido ao cliente não estar ativo na distribuidora'],
+        ['914', 'Não incluído - Cliente já possui o produto ativo', false, '07',
+         'A operação não foi efetuada devido ao cliente já possuir uma adesão vigente. ' \
+         'Só é permitido uma cobrança por vez.'],
+        ['915', 'Cobrança Incluída para o Cliente', true, '10/64',
+         'Confirmação de inclusão de cobrança'],
+        ['916', 'Não Incluído - Cliente sem Fornecimento', false, '63',
+         'Operação não realizada devido ao cliente estar sem fornecimento'],
+        ['917', 'Não incluído - Cliente de classe não permitida', false, '73',
+         'Não é permito incluir para as seguintes classes de clientes: Poderes Públicos, ' \
+         'Iluminação Pública, Serviços Públicos, Consumo Próprio'],
+        ['918', 'Cliente com problema cadastral na distribuidora', false, '98',
+         'O cliente encontra-se com problemas cadastrais que impedem a operação.'],
+        ['920', 'Falha no cancelamento de fatura não emitida', false, nil,
+         'Falha no cancelamento de fatura não emitida devido ao cliente já estar em ' \
+         'processo de faturamento'],
+        ['996', 'Retorno OK para novas vendas / Alteração de valores / Cancelamentos', true,
+         nil, 'Confirmação do ingresso da solicitação na fila de auditoria/processamento. ' \
+              'Retorno após as validações automáticas do sistema.'],
+        ['997', 'Retorno KO para novas vendas / Alteração de valores / Cancelamentos', false,
+         nil, 'Retorno de informação de falha/erro da tentativa de ingresso da solicitação ' \
+              'na fila de auditoria/processamento. Retorno após as validações ' \
+              'automáticas do sistema.'],
+        ['998', 'Retorno OK para auditoria', true, nil,
+         'Retorno de auditoria bem-sucedida'],
+        ['999', 'Retorno KO para auditoria', false, nil,
+         'Retorno de rejeição pela mesa de auditoria'],
+      ].freeze
+
+      ALL = ROWS.map do |code, description, ok, legacy, note|
+        stage = STAGES.find { |_, codes| codes.include?(code) }&.first || :unknown
+        new(code, description, ok, legacy, note, stage)
+      end.freeze
+
+      REASON_TAIL = ' É cancelado a adesão e futuros faturamentos, entretanto os ' \
+                    'faturamentos em aberto permanecem'
+      REQUESTED = 'Cancelamento a pedido do cliente na distribuidora devido '
+
+      REASON_ROWS = [
+        ['02', 'Cancelamento por Mudança de Classe', true,
+         'Cancelamento automático efetuado pela distribuidora, quando é realizada a ' \
+         'mudança de classe (ex: cliente residencial muda para comercial).'],
+        ['20', 'Cancelamento de produto por retirada do cliente do sistema.', true,
+         'Cancelamento automático efetuado pela distribuidora, quando o cliente é ' \
+         'retirado do sistema.'],
+        ['22', 'Cancelado - Fora da faixa etária', false,
+         "#{REQUESTED}estar fora da faixa etária."],
+        ['23', 'Cancelado - Contenção de despesas', false,
+         "#{REQUESTED}a contenção de despesas."],
+        ['24', 'Cancelado - Insatisfação com o produto', false,
+         "#{REQUESTED}insatisfação do produto."],
+        ['25', 'Cancelado - Morte do segurado', false,
+         "#{REQUESTED}a morte do segurado."],
+        ['26', 'Cancelado - Não há interesse', false,
+         "#{REQUESTED}não haver mais interesse."],
+        ['27', 'Cancelado - Adesão indevida', false,
+         "#{REQUESTED}a uma adesão indevida."],
+        ['28', 'Cancelado - Falta de rede credenciada', false,
+         "#{REQUESTED}a falta de rede credenciada."],
+        ['29', 'Cancelado - Não recebimento de certificado / carteirinha', false,
+         "#{REQUESTED}ao motivo não recebimento do certificado / carteirinha."],
+        ['30', 'Cancelado - Determinação judicial', false,
+         "#{REQUESTED}ao motivo determinação judicial."],
+        ['31', 'Cancelado - Cancelamento solicitado e não atendido', false,
+         "#{REQUESTED}ao motivo cancelamento solicitado e não atendido."],
+        ['32', 'Cancelado - Contratação de outro produto', false,
+         "#{REQUESTED}ao motivo contratação de outro produto."],
+        ['33', 'Cancelado - Cancelado por troca de titularidade', false,
+         "#{REQUESTED}ao motivo cancelado por troca de titularidade."],
+      ].freeze
+
+      CANCELLATION_REASONS = REASON_ROWS.map do |code, description, automatic, text|
+        CancellationReason.new(code, description, automatic, "#{text}#{REASON_TAIL}")
+      end.freeze
+
+      def ok? = ok
+
+      class << self
+        def all = ALL
+
+        def find(code)
+          ALL.find { |item| item.code == code.to_s }
+        end
+
+        def cancellation_reason(code)
+          CANCELLATION_REASONS.find { |item| item.code == code.to_s }
+        end
+
+        # Unknown codes still get an object, so callers can keep the raw code.
+        def fetch(code)
+          find(code) || new(code.to_s, nil, nil, nil, nil, :unknown)
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Layout/LineLength

data/lib/enel_x/reference/partner_code.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module EnelX
+  module Reference
+    # Codes the partner sends in codOcorr (PDF 7.1).
+    class PartnerCode < Data.define(:code, :description, :note)
+      CANCELLATION_NOTE = 'Cancelamento a pedido. É cancelado a adesão e futuros ' \
+                          'faturamentos, entretanto os faturamentos em aberto permanecem'
+      CHANGE_CODE = '61'
+
+      ALL = [
+        new('22', 'Cancelamento - Fora da faixa etária', CANCELLATION_NOTE),
+        new('23', 'Cancelamento - Contenção de despesas', CANCELLATION_NOTE),
+        new('24', 'Cancelamento - Insatisfação com produto', CANCELLATION_NOTE),
+        new('25', 'Cancelamento - Morte do segurado', CANCELLATION_NOTE),
+        new('26', 'Cancelamento - Não há interesse', CANCELLATION_NOTE),
+        new('27', 'Cancelamento - Adesão indevida', CANCELLATION_NOTE),
+        new('28', 'Cancelamento - Falta de rede credenciada', CANCELLATION_NOTE),
+        new('29', 'Cancelamento - Não recebimento de certificado / carteirinha',
+          CANCELLATION_NOTE),
+        new('30', 'Cancelamento - Determinação judicial', CANCELLATION_NOTE),
+        new('31', 'Cancelamento - Cancelamento solicitado e não atendido',
+          CANCELLATION_NOTE),
+        new('32', 'Cancelamento - Contratação de outro seguro', CANCELLATION_NOTE),
+        new(CHANGE_CODE, 'Alteração de débito de produto',
+          'Altera valor e parcelas de uma cobrança ativa. É necessário existir ' \
+          'uma cobrança vigente ativa.'),
+      ].freeze
+
+      class << self
+        def all = ALL
+
+        def find(code)
+          ALL.find { |item| item.code == code.to_s }
+        end
+
+        def cancellation_reasons
+          ALL.select { |item| item.code.to_i.between?(22, 32) }
+        end
+      end
+    end
+  end
+end

data/lib/enel_x/reference.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative 'reference/distributor'
+require_relative 'reference/document_state'
+require_relative 'reference/occurrence'
+require_relative 'reference/partner_code'
+
+module EnelX
+  # The spec names these at the top level; they live under Reference.
+  Distributor = Reference::Distributor
+  Occurrence = Reference::Occurrence
+  DocumentState = Reference::DocumentState
+end

data/lib/enel_x/response_parser.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'error_catalog'
+
+module EnelX
+  # The API answers HTTP 200 even on failure: the body decides (PDF 5.1 and 7.3).
+  module ResponseParser
+    module_function
+
+    # Returns the parsed body (Hash or Array) or raises EnelX::Error.
+    def parse(response, transaction_id: nil)
+      body = decode(response, transaction_id)
+      return body if body.is_a?(Array)
+
+      result = fetch_ci(body, 'result')
+      return check_result(result, body, transaction_id) if result.is_a?(Hash)
+      return body if body.values.any?(Array)
+
+      raise retryable('unexpected response shape', response, transaction_id)
+    end
+
+    def decode(response, transaction_id)
+      body = JSON.parse(response.body.to_s)
+      return body if body.is_a?(Hash) || body.is_a?(Array)
+
+      raise retryable('unreadable response body', response, transaction_id)
+    rescue JSON::ParserError
+      raise retryable('unreadable response body', response, transaction_id)
+    end
+
+    def check_result(result, body, transaction_id)
+      code = fetch_ci(result, 'error_code', 'errorcode').to_s
+      return body if code == '0'
+
+      raise ErrorCatalog.build_error(
+        fetch_ci(result, 'message').to_s, code:, transaction_id:
+      )
+    end
+
+    def retryable(text, response, transaction_id)
+      Error.new("#{text} (HTTP #{response.status})", kind: :retryable,
+        transaction_id:)
+    end
+
+    # Key lookup ignoring case and underscores: result/Result, error_code/ErrorCode.
+    def fetch_ci(hash, *names)
+      wanted = names.map { |name| name.delete('_').downcase }
+      hash.each do |key, value|
+        return value if wanted.include?(key.to_s.delete('_').downcase)
+      end
+      nil
+    end
+  end
+end

data/lib/enel_x/result.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative 'response_parser'
+
+module EnelX
+  # Outcome of a successful business call. For writes, success only means "received":
+  # confirmation arrives later as occurrences (PDF 2.3). transaction_id correlates the
+  # call with the logs of the consumer and of the Enel X.
+  Result = Data.define(:transaction_id, :error_code, :message, :body) do
+    def self.build(body, transaction_id)
+      result = body.is_a?(Hash) ? ResponseParser.fetch_ci(body, 'result') : nil
+      return new(transaction_id, nil, nil, body) unless result.is_a?(Hash)
+
+      new(transaction_id, ResponseParser.fetch_ci(result, 'error_code').to_s,
+        ResponseParser.fetch_ci(result, 'message').to_s.strip, body)
+    end
+  end
+end

data/lib/enel_x/token_provider.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative 'errors'
+
+module EnelX
+  # OAuth2 client_credentials token (PDF 3.1 and 3.2), cached until shortly before expiry.
+  class TokenProvider
+    PATH = '/services/token/oauth2'
+    EXPIRY_MARGIN = 120
+
+    def initialize(configuration, http)
+      @configuration = configuration
+      @http = http
+    end
+
+    def token
+      cache.read(cache_key) || fetch
+    end
+
+    def invalidate
+      cache.delete(cache_key)
+    end
+
+    private
+
+    def cache
+      @configuration.cache
+    end
+
+    def cache_key
+      "enel_x:token:#{@configuration.host}:#{@configuration.client_id}"
+    end
+
+    def fetch
+      response = @http.request(
+        :post, "#{@configuration.host}#{PATH}",
+        headers:, body: 'grant_type=client_credentials'
+      )
+      access_token, expires_in = parse(response)
+      cache.write(cache_key, access_token,
+        expires_in: [expires_in - EXPIRY_MARGIN, 1].max)
+      access_token
+    end
+
+    def headers
+      credentials = "#{@configuration.client_id}:#{@configuration.client_secret}"
+      {
+        'Authorization' => "Basic #{[credentials].pack('m0')}",
+        'Content-Type' => 'application/x-www-form-urlencoded',
+      }
+    end
+
+    def parse(response)
+      if response.status >= 500
+        raise Error.new("token endpoint failed (HTTP #{response.status})",
+          kind: :retryable)
+      end
+      unless response.status == 200
+        raise ConfigurationError,
+          "token endpoint rejected credentials (HTTP #{response.status})"
+      end
+
+      body = JSON.parse(response.body)
+      [body.fetch('access_token'), Integer(body.fetch('expires_in'))]
+    rescue JSON::ParserError, KeyError, TypeError, ArgumentError
+      raise ConfigurationError, 'token endpoint returned an unexpected response'
+    end
+  end
+end

data/lib/enel_x/validators.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'date'
+
+require_relative 'errors'
+require_relative 'filter'
+require_relative 'reference/distributor'
+
+module EnelX
+  # Field rules from PDF 5.3 to 5.5. Each method returns the value to send or raises
+  # ValidationError naming the field and the limit, before any network call.
+  module Validators
+    EMAIL = /\A[A-Za-z0-9_.-]+@[A-Za-z0-9_.-]+\.[A-Za-z]{1,3}\z/
+    MAX_INSTALLMENTS = 400
+    INFINITE_INSTALLMENTS = -1
+
+    module_function
+
+    def invalid(field, limit, value = nil)
+      raise ValidationError.new(
+        "invalid #{field}: #{limit}", field:, limit:,
+        value_preview: Filter.apply({ field => value })[field]
+      )
+    end
+
+    def text(field, value, max:, required: true)
+      string = value.to_s
+      invalid(field, 'required', value) if required && string.strip.empty?
+      invalid(field, "at most #{max} characters", value) if string.length > max
+      string
+    end
+
+    def phone(field, value)
+      digits = value.to_s.gsub(/\D/, '')
+      invalid(field, '10 or 11 digits', value) unless digits.match?(/\A\d{10,11}\z/)
+      digits
+    end
+
+    # An empty e-mail is valid: the PDF advises it when the address may be in use.
+    def email(field, value)
+      string = value.to_s
+      return string if string.empty?
+
+      invalid(field, 'at most 80 characters', value) if string.length > 80
+      invalid(field, 'format XXX@YYY.ZZZ without # & * or accents', value) unless
+        string.match?(EMAIL)
+      string
+    end
+
+    def cep(field, value)
+      digits = value.to_s.gsub(/\D/, '')
+      invalid(field, 'format 99999-999', value) unless digits.length == 8
+      "#{digits[0, 5]}-#{digits[5, 3]}"
+    end
+
+    # Documents travel as digits only, keeping leading zeros.
+    def digits(field, value, max: 20, exactly: nil)
+      string = value.to_s.gsub(/\D/, '')
+      invalid(field, 'digits only', value) if string.empty?
+      invalid(field, "#{exactly} digits", value) if exactly && string.length != exactly
+      invalid(field, "at most #{max} digits", value) if string.length > max
+      string
+    end
+
+    def company(field, value)
+      return value.to_s if Reference::Distributor.find_by_code(value)
+
+      codes = Reference::Distributor.all.map(&:code).join(', ')
+      invalid(field, "one of #{codes}", value)
+    end
+
+    def installments(field, value)
+      number = value.is_a?(Integer) ? value : Integer(value.to_s, 10)
+      return number if number == INFINITE_INSTALLMENTS || number.between?(1,
+        MAX_INSTALLMENTS)
+
+      invalid(field, "-1 or 1 to #{MAX_INSTALLMENTS}", value)
+    rescue ArgumentError, TypeError
+      invalid(field, "-1 or 1 to #{MAX_INSTALLMENTS}", value)
+    end
+
+    # Dot as decimal separator, at most two places. Strings with comma are refused.
+    # Pure string arithmetic: bigdecimal is a bundled gem since Ruby 3.4, not stdlib.
+    def amount(field, value, allow_zero: false)
+      whole, fraction = decimal_text(field, value).split('.')
+      if whole.match?(/\A0+\z/) && fraction.to_s.match?(/\A0*\z/) && !allow_zero
+        invalid(field, 'positive', value)
+      end
+      "#{Integer(whole, 10)}.#{fraction.to_s.ljust(2, '0')}"
+    end
+
+    # A BigDecimal prints as plain text with to_s('F'); any other value uses to_s.
+    def decimal_text(field, value)
+      text = bigdecimal?(value) ? value.to_s('F') : value.to_s
+      return text if text.match?(/\A\d+(\.\d{1,2})?\z/)
+
+      invalid(field, 'positive number with dot and up to 2 decimals', value)
+    end
+
+    # By name, so the constant is not needed (and the gem not required) here.
+    def bigdecimal?(value)
+      value.class.name == 'BigDecimal' # rubocop:disable Style/ClassEqualityComparison
+    end
+
+    def date(field, value)
+      return value.strftime('%Y-%m-%d') if value.is_a?(Date)
+
+      string = value.to_s
+      unless string.match?(/\A\d{4}-\d{2}-\d{2}\z/)
+        invalid(field, 'format YYYY-MM-DD',
+          value)
+      end
+      Date.strptime(string, '%Y-%m-%d')
+      string
+    rescue Date::Error
+      invalid(field, 'format YYYY-MM-DD', value)
+    end
+
+    def one_of(field, value, allowed)
+      return value.to_s if allowed.include?(value.to_s)
+
+      invalid(field, "one of #{allowed.join(', ')}", value)
+    end
+  end
+end

data/lib/enel_x/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EnelX
+  VERSION = File.read(File.expand_path('../../REVISION', __dir__)).strip
+end

data/lib/enel_x.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative 'enel_x/version'
+require_relative 'enel_x/errors'
+require_relative 'enel_x/error_catalog'
+require_relative 'enel_x/response_parser'
+require_relative 'enel_x/configuration'
+require_relative 'enel_x/filter'
+require_relative 'enel_x/endpoint'
+require_relative 'enel_x/headers'
+require_relative 'enel_x/reference'
+require_relative 'enel_x/validators'
+require_relative 'enel_x/attachment'
+require_relative 'enel_x/record'
+require_relative 'enel_x/result'
+require_relative 'enel_x/client'
+
+module EnelX
+  class << self
+    attr_writer :configuration
+
+    # Restores global state; specs call it before and after each example.
+    def reset!
+      @configuration = nil
+    end
+  end
+end