gobl 0.1.2

data/lib/gobl/bill/exchange_rates.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Bill
+    # ExchangeRates represents an array of currency exchange rates.
+    class ExchangeRates < GOBL::Struct
+      extend Forwardable
+      include Enumerable
+
+      # The Schema ID of the GOBL ExchangeRates structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/bill/invoice#/$defs/ExchangeRates'
+
+      attribute :_ary, GOBL::Types::Array.of(GOBL::Currency::ExchangeRate)
+
+      # @!method [](*args)
+      #   Returns elements from the array
+      #   @overload [](index)
+      #     Returns the element in a specific position
+      #     @param index [Integer] the position of the object
+      #     @return [GOBL::Currency::ExchangeRate] the element in the `index` position
+      #   @overload [](start, length)
+      #     Returns all the elements within a range of positions
+      #     @param start [Integer] start position of the range
+      #     @param length [Integer] length of the range
+      #     @return [Array<GOBL::Currency::ExchangeRate>] the elements in the range
+      #   @overload [](range)
+      #     Returns all the elements within a range
+      #     @param range [Range] start and end positions of the range
+      #     @return [Array<GOBL::Currency::ExchangeRate>] the elements in the range
+      #
+      # @!method each
+      #   Iterates over the array elements
+      #   @overload each(&block)
+      #     Calls the given block with each element in the array
+      #     @yield [element] element of the array
+      #     @return [self] the object itself
+      #   @overload each
+      #     Returns an Enumerator that iterates over the array elements
+      #     @return [Enumerator] the enumerator of the array elements
+      #
+      # @!method empty?
+      #   Returns `true` if the number of elements in the array is zero, `false` otherwise.
+      #   @return [Boolean] whether the array is empty or not
+      #
+      # @!method length
+      #   Returns the number of elements in the array
+      #   @return [Integer] the number of elements in the array
+      def_delegators :_ary, :[], :each, :empty?, :length
+
+      # Creates a new object from an array of GOBL data
+      #
+      # @param data [Array] an array of GOBL data
+      #
+      # @return [ExchangeRates] the object created from the given data
+      def self.from_gobl!(data)
+        new(_ary: data&.map { |item| GOBL::Currency::ExchangeRate.from_gobl!(item) })
+      end
+
+      # Returns an array of GOBL data representing the current object
+      #
+      # @return [Array<Hash>] the array of GOBL data that represents the current object
+      def to_gobl
+        _ary.map(&:to_gobl)
+      end
+
+      # Returns a {ExchangeRates} object from a given array of structs. The array may
+      # contain {GOBL::Currency::ExchangeRate} objects or hashes. If hashes are provided, the constructor
+      # will call `GOBL::Currency::ExchangeRate#new` to generate the objects that will be part of the
+      # returned {ExchangeRates} object
+      #
+      # @param object [Array<GOBL::Currency::ExchangeRate, Hash>] the array containing the structs
+      #
+      # @return [ExchangeRates] the object corresponding to the given input
+      def self.new(object)
+        case object
+        when Array
+          super _ary: object
+        else # internal use, not to be used in public calls
+          super
+        end
+      end
+    end
+  end
+end

data/lib/gobl/bill/invoice.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Bill
+    # Invoice represents a payment claim for goods or services supplied under conditions agreed between the supplier and the customer.
+    class Invoice < GOBL::Struct
+      # The Schema ID of the GOBL Invoice structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/bill/invoice'
+
+      # @!attribute [r] uuid
+      # Unique document ID. Not required, but always recommended in addition to the Code.
+      # @return [GOBL::UUID::UUID]
+      attribute? :uuid, GOBL::UUID::UUID.optional
+
+      # @!attribute [r] code
+      # Sequential code used to identify this invoice in tax declarations.
+      # @return [String]
+      attribute :code, GOBL::Types::String
+
+      # @!attribute [r] series
+      # Used in addition to the Code in some regions.
+      # @return [String]
+      attribute? :series, GOBL::Types::String.optional
+
+      # @!attribute [r] type
+      # Optional invoice type, leave empty unless needed for a specific situation.
+      # @return [InvoiceType]
+      attribute? :type, InvoiceType.optional
+
+      # @!attribute [r] currency
+      # Currency for all invoice totals.
+      # @return [GOBL::Currency::Code]
+      attribute :currency, GOBL::Currency::Code
+
+      # @!attribute [r] exchange_rates
+      # Exchange rates to be used when converting the invoices monetary values into other currencies.
+      # @return [ExchangeRates]
+      attribute? :exchange_rates, ExchangeRates.optional
+
+      # @!attribute [r] tax
+      # Special tax configuration for billing.
+      # @return [Tax]
+      attribute? :tax, Tax.optional
+
+      # @!attribute [r] preceding
+      # Key information regarding a previous invoice and potentially details as to why it was corrected.
+      # @return [Preceding]
+      attribute? :preceding, Preceding.optional
+
+      # @!attribute [r] issue_date
+      # When the invoice was created.
+      # @return [GOBL::Cal::Date]
+      attribute :issue_date, GOBL::Cal::Date
+
+      # @!attribute [r] op_date
+      # Date when the operation defined by the invoice became effective.
+      # @return [GOBL::Cal::Date]
+      attribute? :op_date, GOBL::Cal::Date.optional
+
+      # @!attribute [r] value_date
+      # When the taxes of this invoice become accountable, if none set, the issue date is used.
+      # @return [GOBL::Cal::Date]
+      attribute? :value_date, GOBL::Cal::Date.optional
+
+      # @!attribute [r] supplier
+      # The taxable entity supplying the goods or services.
+      # @return [GOBL::Org::Party]
+      attribute :supplier, GOBL::Org::Party
+
+      # @!attribute [r] customer
+      # Legal entity receiving the goods or services, may be empty in certain circumstances such as simplified invoices.
+      # @return [GOBL::Org::Party]
+      attribute? :customer, GOBL::Org::Party.optional
+
+      # @!attribute [r] lines
+      # List of invoice lines representing each of the items sold to the customer.
+      # @return [Array<Line>]
+      attribute? :lines, GOBL::Types::Array.of(Line).optional
+
+      # @!attribute [r] discounts
+      # Discounts or allowances applied to the complete invoice
+      # @return [Array<Discount>]
+      attribute? :discounts, GOBL::Types::Array.of(Discount).optional
+
+      # @!attribute [r] charges
+      # Charges or surcharges applied to the complete invoice
+      # @return [Array<Charge>]
+      attribute? :charges, GOBL::Types::Array.of(Charge).optional
+
+      # @!attribute [r] outlays
+      # Expenses paid for by the supplier but invoiced directly to the customer.
+      # @return [Array<Outlay>]
+      attribute? :outlays, GOBL::Types::Array.of(Outlay).optional
+
+      # @!attribute [r] ordering
+      # @return [Ordering]
+      attribute? :ordering, Ordering.optional
+
+      # @!attribute [r] payment
+      # @return [Payment]
+      attribute? :payment, Payment.optional
+
+      # @!attribute [r] delivery
+      # @return [Delivery]
+      attribute? :delivery, Delivery.optional
+
+      # @!attribute [r] totals
+      # Summary of all the invoice totals, including taxes (calculated).
+      # @return [Totals]
+      attribute? :totals, Totals.optional
+
+      # @!attribute [r] notes
+      # Unstructured information that is relevant to the invoice, such as correction or additional legal details.
+      # @return [Array<GOBL::Org::Note>]
+      attribute? :notes, GOBL::Types::Array.of(GOBL::Org::Note).optional
+
+      # @!attribute [r] meta
+      # Additional semi-structured data that doesn't fit into the body of the invoice.
+      # @return [GOBL::Org::Meta]
+      attribute? :meta, GOBL::Org::Meta.optional
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [Invoice] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          uuid: data['uuid'] ? GOBL::UUID::UUID.from_gobl!(data['uuid']) : nil,
+          code: data['code'],
+          series: data['series'],
+          type: data['type'] ? InvoiceType.from_gobl!(data['type']) : nil,
+          currency: GOBL::Currency::Code.from_gobl!(data['currency']),
+          exchange_rates: data['exchange_rates'] ? ExchangeRates.from_gobl!(data['exchange_rates']) : nil,
+          tax: data['tax'] ? Tax.from_gobl!(data['tax']) : nil,
+          preceding: data['preceding'] ? Preceding.from_gobl!(data['preceding']) : nil,
+          issue_date: GOBL::Cal::Date.from_gobl!(data['issue_date']),
+          op_date: data['op_date'] ? GOBL::Cal::Date.from_gobl!(data['op_date']) : nil,
+          value_date: data['value_date'] ? GOBL::Cal::Date.from_gobl!(data['value_date']) : nil,
+          supplier: GOBL::Org::Party.from_gobl!(data['supplier']),
+          customer: data['customer'] ? GOBL::Org::Party.from_gobl!(data['customer']) : nil,
+          lines: data['lines']&.map { |item| Line.from_gobl!(item) },
+          discounts: data['discounts']&.map { |item| Discount.from_gobl!(item) },
+          charges: data['charges']&.map { |item| Charge.from_gobl!(item) },
+          outlays: data['outlays']&.map { |item| Outlay.from_gobl!(item) },
+          ordering: data['ordering'] ? Ordering.from_gobl!(data['ordering']) : nil,
+          payment: data['payment'] ? Payment.from_gobl!(data['payment']) : nil,
+          delivery: data['delivery'] ? Delivery.from_gobl!(data['delivery']) : nil,
+          totals: data['totals'] ? Totals.from_gobl!(data['totals']) : nil,
+          notes: data['notes']&.map { |item| GOBL::Org::Note.from_gobl!(item) },
+          meta: data['meta'] ? GOBL::Org::Meta.from_gobl!(data['meta']) : nil
+        )
+      end
+
+      # Returns a hash of GOBL data representing the current object
+      #
+      # @return [Hash] the array of GOBL data that represents the current object
+      def to_gobl
+        {
+          'uuid' => attributes[:uuid]&.to_gobl,
+          'code' => attributes[:code],
+          'series' => attributes[:series],
+          'type' => attributes[:type]&.to_gobl,
+          'currency' => attributes[:currency]&.to_gobl,
+          'exchange_rates' => attributes[:exchange_rates]&.to_gobl,
+          'tax' => attributes[:tax]&.to_gobl,
+          'preceding' => attributes[:preceding]&.to_gobl,
+          'issue_date' => attributes[:issue_date]&.to_gobl,
+          'op_date' => attributes[:op_date]&.to_gobl,
+          'value_date' => attributes[:value_date]&.to_gobl,
+          'supplier' => attributes[:supplier]&.to_gobl,
+          'customer' => attributes[:customer]&.to_gobl,
+          'lines' => attributes[:lines]&.map { |item| item&.to_gobl },
+          'discounts' => attributes[:discounts]&.map { |item| item&.to_gobl },
+          'charges' => attributes[:charges]&.map { |item| item&.to_gobl },
+          'outlays' => attributes[:outlays]&.map { |item| item&.to_gobl },
+          'ordering' => attributes[:ordering]&.to_gobl,
+          'payment' => attributes[:payment]&.to_gobl,
+          'delivery' => attributes[:delivery]&.to_gobl,
+          'totals' => attributes[:totals]&.to_gobl,
+          'notes' => attributes[:notes]&.map { |item| item&.to_gobl },
+          'meta' => attributes[:meta]&.to_gobl
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {Invoice} object from a given hash of attributes. Nested
+      #   attributes are supported: the constructor will instantiate the proper GOBL
+      #   objects when nested hashes or arrays are given as part of the `attrs`
+      #   parameter.
+      #
+      #   The `new` method will only allow to create a new object if all attributes
+      #   marked as mandatory and not calculated in the JSON schema are provided.
+      #
+      #   @param attrs [Hash] the hash of attributes
+      #
+      #   @return [Invoice] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/bill/invoice_type.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Bill
+    # Defines an invoice type according to a subset of the UNTDID 1001 standard list.
+    class InvoiceType < GOBL::Struct
+      # The Schema ID of the GOBL InvoiceType structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/bill/invoice#/$defs/InvoiceType'
+
+      # The enumeration of values of the object and their descriptions (Values different to these are not allowed)
+      ENUM = {
+        'proforma' => 'Proforma invoice, for a clients validation before sending a final invoice.',
+        'simplified' => 'Simplified invoice or receipt typically used for small transactions that dont require customer details.t require customer details.',
+        'partial' => 'Partial invoice',
+        'commercial' => 'Commercial invoice, usually cross-border transactions requiring an invoice for customs.',
+        'corrected' => 'Corrected invoice',
+        'credit-note' => 'Credit note',
+        'self-billed' => 'Self billed invoice'
+      }.freeze
+
+      attribute :_value, GOBL::Types::String.enum(*ENUM.keys)
+      private :_value
+
+      # Creates a new object from a GOBL value
+      #
+      # @param data [String] the GOBL value
+      #
+      # @return [InvoiceType] the object created from the given data
+      def self.from_gobl!(data)
+        new(_value: data)
+      end
+
+      # Returns a GOBL value representing the current object
+      #
+      # @return [String] the GOBL value that represents the current object
+      def to_gobl
+        _value
+      end
+
+      # Returns a {InvoiceType} that corresponds to a given object. The object can be a
+      # `Symbol`, a `String` or anything coercible into one (via `#to_s`).
+      #
+      # @param object [Symbol, String, #to_s] the value of the object.
+      #
+      # @return [InvoiceType] the object corresponding to the given value.
+      #
+      # @example Instantiating from a symbol
+      #   invoice_type = GOBL::Bill::InvoiceType.new(:proforma)
+      #
+      # @example Instantiating from a string
+      #   invoice_type = GOBL::Bill::InvoiceType.new('proforma')
+      def self.new(object)
+        case object
+        when Hash, self # internal use, not to be used in public calls
+          super
+        when Symbol
+          new find_by_sym(object)
+        else
+          super _value: object.to_s
+        end
+      end
+
+      # Returns the string representation of the current object
+      #
+      # @return [String] the string representation of the current object
+      def to_s
+        _value.to_s
+      end
+
+      # Returns the symbol representation of the current object
+      #
+      # @return [Symbol] the symbol representation of the current object
+      def to_sym
+        to_s.parameterize.underscore.to_sym
+      end
+
+      # Returns whether the current object is equivalent to a given one. In addition
+      # to {InvoiceType} objects, the current object can be compared to a `Symbol`, a
+      # `String` or anything coercible into one (via `#to_s`)
+      #
+      # @param other [InvoiceType, Symbol, String, #to_s] the other object to compare to
+      #
+      # @return [Boolean] `true` if the objects are equivalent, `false` otherwise
+      #
+      # @example Comparing to another {InvoiceType} object
+      #   invoice_type = GOBL::Bill::InvoiceType.new('proforma')
+      #   invoice_type == GOBL::Bill::InvoiceType.new('proforma') #=> true
+      #   invoice_type == GOBL::Bill::InvoiceType.new('simplified') #=> false
+      #
+      # @example Comparing to a string
+      #   invoice_type = GOBL::Bill::InvoiceType.new('proforma')
+      #   invoice_type == 'proforma' #=> true
+      #   invoice_type == 'simplified' #=> false
+      #
+      # @example Comparing to a symbol
+      #   invoice_type = GOBL::Bill::InvoiceType.new('proforma')
+      #   invoice_type == :proforma #=> true
+      #   invoice_type == :simplified #=> false
+      def ==(other)
+        case other
+        when self.class
+          super
+        when Symbol
+          to_sym == other
+        else
+          to_s == other.to_s
+        end
+      end
+
+      # Returns an array with all the enumerated objects of this type
+      #
+      # @return [Array<InvoiceType>] the array of enumerated objects
+      def self.all
+        ENUM.keys.map { |key| new(key) }
+      end
+
+      # @api private
+      def self.find_by_sym(sym)
+        all.find { |object| object.to_sym == sym }
+      end
+
+      # @api private
+      def self.find_by_inquirer(method_name)
+        method_name =~ /(.+)\?$/ && find_by_sym(Regexp.last_match(1).to_sym)
+      end
+
+      # Returns the description of the current object
+      #
+      # @return [String] the description of the current object
+      def description
+        ENUM.fetch(_value, _value)
+      end
+
+      # @api private
+      def respond_to_missing?(method_name, include_private = false)
+        self.class.find_by_inquirer(method_name) || super
+      end
+
+      # Enables dynamic value inquirers like `InvoiceType#proforma?` for
+      # each of the declared enum values (see {ENUM}). Each inquirer returns a
+      # `Boolean` denoting whether the value equals the enquired value (`true`) or
+      # not (`false`)
+      #
+      # @example
+      #   invoice_type = GOBL::Bill::InvoiceType.new('proforma')
+      #   invoice_type.proforma? # => true
+      #   invoice_type.simplified? # => false
+      def method_missing(method_name, *args, &block)
+        if value = self.class.find_by_inquirer(method_name)
+          self == value
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/gobl/bill/line.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Bill
+    # Line is a single row in an invoice.
+    class Line < GOBL::Struct
+      # The Schema ID of the GOBL Line structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/bill/invoice#/$defs/Line'
+
+      # @!attribute [r] uuid
+      # Unique identifier for this line
+      # @return [GOBL::UUID::UUID]
+      attribute? :uuid, GOBL::UUID::UUID.optional
+
+      # @!attribute [r] i
+      # Line number inside the parent (calculated)
+      # @return [Integer]
+      attribute? :i, GOBL::Types::Int.optional
+
+      # @!attribute [r] quantity
+      # Number of items
+      # @return [GOBL::Num::Amount]
+      attribute :quantity, GOBL::Types.Constructor(GOBL::Num::Amount)
+
+      # @!attribute [r] item
+      # Details about what is being sold
+      # @return [GOBL::Org::Item]
+      attribute :item, GOBL::Org::Item
+
+      # @!attribute [r] sum
+      # Result of quantity multiplied by the item's price (calculated)
+      # @return [GOBL::Num::Amount]
+      attribute? :sum, GOBL::Types.Constructor(GOBL::Num::Amount).optional
+
+      # @!attribute [r] discounts
+      # Discounts applied to this line
+      # @return [Array<LineDiscount>]
+      attribute? :discounts, GOBL::Types::Array.of(LineDiscount).optional
+
+      # @!attribute [r] charges
+      # Charges applied to this line
+      # @return [Array<LineCharge>]
+      attribute? :charges, GOBL::Types::Array.of(LineCharge).optional
+
+      # @!attribute [r] taxes
+      # Map of taxes to be applied and used in the invoice totals
+      # @return [GOBL::Tax::Set]
+      attribute? :taxes, GOBL::Tax::Set.optional
+
+      # @!attribute [r] total
+      # Total line amount after applying discounts to the sum (calculated).
+      # @return [GOBL::Num::Amount]
+      attribute? :total, GOBL::Types.Constructor(GOBL::Num::Amount).optional
+
+      # @!attribute [r] notes
+      # Set of specific notes for this line that may be required for clarification.
+      # @return [Array<GOBL::Org::Note>]
+      attribute? :notes, GOBL::Types::Array.of(GOBL::Org::Note).optional
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [Line] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          uuid: data['uuid'] ? GOBL::UUID::UUID.from_gobl!(data['uuid']) : nil,
+          i: data['i'],
+          quantity: data['quantity'],
+          item: GOBL::Org::Item.from_gobl!(data['item']),
+          sum: data['sum'] || nil,
+          discounts: data['discounts']&.map { |item| LineDiscount.from_gobl!(item) },
+          charges: data['charges']&.map { |item| LineCharge.from_gobl!(item) },
+          taxes: data['taxes'] ? GOBL::Tax::Set.from_gobl!(data['taxes']) : nil,
+          total: data['total'] || nil,
+          notes: data['notes']&.map { |item| GOBL::Org::Note.from_gobl!(item) }
+        )
+      end
+
+      # Returns a hash of GOBL data representing the current object
+      #
+      # @return [Hash] the array of GOBL data that represents the current object
+      def to_gobl
+        {
+          'uuid' => attributes[:uuid]&.to_gobl,
+          'i' => attributes[:i],
+          'quantity' => attributes[:quantity]&.to_gobl,
+          'item' => attributes[:item]&.to_gobl,
+          'sum' => attributes[:sum]&.to_gobl,
+          'discounts' => attributes[:discounts]&.map { |item| item&.to_gobl },
+          'charges' => attributes[:charges]&.map { |item| item&.to_gobl },
+          'taxes' => attributes[:taxes]&.to_gobl,
+          'total' => attributes[:total]&.to_gobl,
+          'notes' => attributes[:notes]&.map { |item| item&.to_gobl }
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {Line} object from a given hash of attributes. Nested
+      #   attributes are supported: the constructor will instantiate the proper GOBL
+      #   objects when nested hashes or arrays are given as part of the `attrs`
+      #   parameter.
+      #
+      #   The `new` method will only allow to create a new object if all attributes
+      #   marked as mandatory and not calculated in the JSON schema are provided.
+      #
+      #   @param attrs [Hash] the hash of attributes
+      #
+      #   @return [Line] the object corresponding to the given input
+    end
+  end
+end

data/lib/gobl/bill/line_charge.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+##
+## DO NOT EDIT - This file was generated automatically.
+##
+## Generated with GOBL v0.30.4
+##
+
+module GOBL
+  module Bill
+    # LineCharge represents an amount added to the line, and will be applied before taxes.
+    class LineCharge < GOBL::Struct
+      # The Schema ID of the GOBL LineCharge structure
+      SCHEMA_ID = 'https://gobl.org/draft-0/bill/invoice#/$defs/LineCharge'
+
+      # @!attribute [r] percent
+      # Percentage if fixed amount not applied
+      # @return [GOBL::Num::Percentage]
+      attribute? :percent, GOBL::Types.Constructor(GOBL::Num::Percentage).optional
+
+      # @!attribute [r] amount
+      # Fixed or resulting charge amount to apply (calculated if percent present).
+      # @return [GOBL::Num::Amount]
+      attribute? :amount, GOBL::Types.Constructor(GOBL::Num::Amount).optional
+
+      # @!attribute [r] code
+      # Reference code.
+      # @return [String]
+      attribute? :code, GOBL::Types::String.optional
+
+      # @!attribute [r] reason
+      # Text description as to why the charge was applied
+      # @return [String]
+      attribute? :reason, GOBL::Types::String.optional
+
+      # Creates a new object from a hash of GOBL data
+      #
+      # @param data [Hash] a hash of GOBL data
+      #
+      # @return [LineCharge] the object created from the given data
+      def self.from_gobl!(data)
+        data = GOBL::Types::Hash[data]
+
+        new(
+          percent: data['percent'] || nil,
+          amount: data['amount'] || nil,
+          code: data['code'],
+          reason: data['reason']
+        )
+      end
+
+      # Returns a hash of GOBL data representing the current object
+      #
+      # @return [Hash] the array of GOBL data that represents the current object
+      def to_gobl
+        {
+          'percent' => attributes[:percent]&.to_gobl,
+          'amount' => attributes[:amount]&.to_gobl,
+          'code' => attributes[:code],
+          'reason' => attributes[:reason]
+        }.compact
+      end
+
+      # @!method self.new(attrs)
+      #
+      #   Returns a {LineCharge} object from a given hash of attributes. Nested
+      #   attributes are supported: the constructor will instantiate the proper GOBL
+      #   objects when nested hashes or arrays are given as part of the `attrs`
+      #   parameter.
+      #
+      #   The `new` method will only allow to create a new object if all attributes
+      #   marked as mandatory and not calculated in the JSON schema are provided.
+      #
+      #   @param attrs [Hash] the hash of attributes
+      #
+      #   @return [LineCharge] the object corresponding to the given input
+    end
+  end
+end