starkinfra 0.5.2 → 0.7.0

data/lib/issuing_withdrawal/issuing_withdrawal.rb

@@ -9,8 +9,8 @@ module StarkInfra
   # The IssuingWithdrawal objects created in your Workspace return cash from your Issuing balance to your Banking balance.
   #
   # ## Parameters (required):
-  # - amount [integer]: IssuingWithdrawal value in cents. Minimum = 0 (any value will be accepted). ex: 1234 (= R$ 12.34)
-  # - external_id [string] IssuingWithdrawal external ID. ex: '12345'
+  # - amount [integer]: IssuingWithdrawal value in cents. ex: 1234 (= R$ 12.34)
+  # - external_id [string]: unique identifier for this withdrawal, used to prevent duplicates on retries. ex: '12345'
   # - description [string]: IssuingWithdrawal description. ex: 'sending money back'
   #
   # ## Parameters (optional):

data/lib/ledger/ledger.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+
+module StarkInfra
+  # # Ledger object
+  #
+  # Ledgers are used to track the balance of a given amount by inserting LedgerTransactions to them.
+  # They can represent a bank account, a digital wallet, an inventory product, etc.
+  #
+  # ## Parameters (required):
+  # - external_id [string]: string that must be unique among all your Ledgers. ex: 'my-internal-id-123456'
+  #
+  # ## Parameters (optional):
+  # - rules [list of Ledger::Rule objects, default []]: list of Rule objects linked to the Ledger. Rules are used to limit the balance of the Ledger. ex: [Ledger::Rule.new(key: 'minimumBalance', value: 0)]
+  # - tags [list of strings, default []]: list of strings for reference when searching for Ledgers. ex: ['account/123', 'savings']
+  # - metadata [dictionary, default {}]: dictionary object used to store additional information about the Ledger object. ex: { 'accountId': '123', 'accountType': 'savings' }
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when the Ledger is created. ex: '5656565656565656'
+  # - created [DateTime]: creation datetime for the Ledger. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - updated [DateTime]: latest update datetime for the Ledger. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class Ledger < StarkCore::Utils::Resource
+    attr_reader :external_id, :rules, :tags, :metadata, :id, :created, :updated
+    def initialize(external_id:, id: nil, rules: nil, tags: nil, metadata: nil, created: nil, updated: nil)
+      super(id)
+      @external_id = external_id
+      @rules = StarkInfra::Ledger::Rule.parse_rules(rules)
+      @tags = tags
+      @metadata = metadata
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
+    end
+
+    # # Create Ledgers
+    #
+    # Send a list of Ledger objects for creation at the Stark Infra API
+    #
+    # ## Parameters (required):
+    # - ledgers [list of Ledger objects]: list of Ledger objects to be created in the Stark Infra API. You can send up to 100 Ledger objects in a single request.
+    #
+    # ## Parameters (optional):
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - list of Ledger objects with updated attributes
+    def self.create(ledgers, user: nil)
+      StarkInfra::Utils::Rest.post(entities: ledgers, user: user, **resource)
+    end
+
+    # # Retrieve a specific Ledger
+    #
+    # Receive a single Ledger object previously created in the Stark Infra API by its id
+    #
+    # ## Parameters (required):
+    # - id [string]: object unique id. ex: '5656565656565656'
+    #
+    # ## Parameters (optional):
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - Ledger object with updated attributes
+    def self.get(id, user: nil)
+      StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve Ledgers
+    #
+    # Receive a generator of Ledger objects previously created in the Stark Infra API
+    #
+    # ## Parameters (optional):
+    # - limit [integer, default nil]: maximum number of objects to be retrieved. Unlimited if nil. ex: 35
+    # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+    # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+    # - ids [list of strings, default nil]: list of Ledger ids to filter retrieved objects. ex: ['5656565656565656', '4545454545454545']
+    # - external_ids [list of strings, default nil]: list of Ledger external ids to filter retrieved objects. ex: ['my-internal-id-123456', 'my-internal-id-654321']
+    # - tags [list of strings, default nil]: list of tags to filter retrieved objects. ex: ['account/123', 'savings']
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - generator of Ledger objects with updated attributes
+    def self.query(limit: nil, after: nil, before: nil, ids: nil, external_ids: nil, tags: nil, user: nil)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
+      StarkInfra::Utils::Rest.get_stream(
+        limit: limit,
+        after: after,
+        before: before,
+        ids: ids,
+        external_ids: external_ids,
+        tags: tags,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Retrieve paged Ledgers
+    #
+    # Receive a list of up to 100 Ledger objects previously created in the Stark Infra API and the cursor to the next page.
+    # Use this function instead of query if you want to manually page your requests.
+    #
+    # ## Parameters (optional):
+    # - cursor [string, default nil]: cursor returned on the previous page function call
+    # - limit [integer, default 100]: maximum number of objects to be retrieved. Max = 100. ex: 35
+    # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+    # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+    # - ids [list of strings, default nil]: list of Ledger ids to filter retrieved objects. ex: ['5656565656565656', '4545454545454545']
+    # - external_ids [list of strings, default nil]: list of Ledger external ids to filter retrieved objects. ex: ['my-internal-id-123456', 'my-internal-id-654321']
+    # - tags [list of strings, default nil]: list of tags to filter retrieved objects. ex: ['account/123', 'savings']
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - list of Ledger objects with updated attributes
+    # - cursor to retrieve the next page of Ledger objects
+    def self.page(cursor: nil, limit: nil, after: nil, before: nil, ids: nil, external_ids: nil, tags: nil, user: nil)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
+      StarkInfra::Utils::Rest.get_page(
+        cursor: cursor,
+        limit: limit,
+        after: after,
+        before: before,
+        ids: ids,
+        external_ids: external_ids,
+        tags: tags,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Update Ledger
+    #
+    # Update a Ledger by passing id.
+    #
+    # ## Parameters (required):
+    # - id [string]: Ledger id. ex: '5656565656565656'
+    #
+    # ## Parameters (optional):
+    # - rules [list of Ledger::Rule objects, default nil]: list of Rule objects linked to the Ledger. Rules are used to limit the balance of the Ledger. ex: [Ledger::Rule.new(key: 'minimumBalance', value: 0)]
+    # - tags [list of strings, default nil]: list of strings for reference when searching for Ledgers. ex: ['account/123', 'savings']
+    # - metadata [dictionary, default nil]: dictionary object used to store additional information about the Ledger object. ex: { 'accountId': '123', 'accountType': 'savings' }
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - target Ledger object with updated attributes
+    def self.update(id, rules: nil, tags: nil, metadata: nil, user: nil)
+      StarkInfra::Utils::Rest.patch_id(
+        id: id,
+        rules: rules,
+        tags: tags,
+        metadata: metadata,
+        user: user,
+        **resource
+      )
+    end
+
+    def self.resource
+      {
+        resource_name: 'Ledger',
+        resource_maker: proc { |json|
+          Ledger.new(
+            id: json['id'],
+            external_id: json['external_id'],
+            rules: json['rules'],
+            tags: json['tags'],
+            metadata: json['metadata'],
+            created: json['created'],
+            updated: json['updated']
+          )
+        }
+      }
+    end
+  end
+end

data/lib/ledger/log.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+require_relative('ledger')
+
+module StarkInfra
+  class Ledger
+    # # Ledger::Log object
+    #
+    # Every time a Ledger entity is updated, a corresponding Ledger::Log
+    # is generated for the entity. This log is never generated by the
+    # user, but it can be retrieved to check additional information
+    # on the Ledger.
+    #
+    # ## Attributes (return-only):
+    # - id [string]: unique id returned when the log is created. ex: '5656565656565656'
+    # - created [DateTime]: creation datetime for the log. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+    # - type [string]: type of the Ledger event which triggered the log creation. ex: 'created', 'updated'
+    # - ledger [Ledger]: Ledger entity to which the log refers to.
+    class Log < StarkCore::Utils::Resource
+      attr_reader :id, :created, :type, :ledger
+      def initialize(id:, created:, type:, ledger:)
+        super(id)
+        @type = type
+        @ledger = ledger
+        @created = StarkCore::Utils::Checks.check_datetime(created)
+      end
+
+      # # Retrieve a specific Ledger::Log
+      #
+      # Receive a single Ledger::Log object previously created by the Stark Infra API by its id
+      #
+      # ## Parameters (required):
+      # - id [string]: object unique id. ex: '5656565656565656'
+      #
+      # ## Parameters (optional):
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+      #
+      # ## Return:
+      # - Ledger::Log object with updated attributes
+      def self.get(id, user: nil)
+        StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+      end
+
+      # # Retrieve Ledger::Logs
+      #
+      # Receive a generator of Ledger::Log objects previously created in the Stark Infra API
+      #
+      # ## Parameters (optional):
+      # - ids [list of strings, default nil]: list of LedgerLog ids to filter retrieved objects. ex: ['5656565656565656', '4545454545454545']
+      # - limit [integer, default nil]: maximum number of objects to be retrieved. Unlimited if nil. ex: 35
+      # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+      # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+      # - ledger_id [string, default nil]: filter logs by Ledger id. ex: '5656565656565656'
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+      #
+      # ## Return:
+      # - generator of Ledger::Log objects with updated attributes
+      def self.query(ids: nil, limit: nil, after: nil, before: nil, ledger_id: nil, user: nil)
+        after = StarkCore::Utils::Checks.check_date(after)
+        before = StarkCore::Utils::Checks.check_date(before)
+        StarkInfra::Utils::Rest.get_stream(
+          ids: ids,
+          limit: limit,
+          after: after,
+          before: before,
+          ledger_id: ledger_id,
+          user: user,
+          **resource
+        )
+      end
+
+      # # Retrieve paged Ledger::Logs
+      #
+      # Receive a list of up to 100 Ledger::Log objects previously created in the Stark Infra API and the cursor to the next page.
+      # Use this function instead of query if you want to manually page your requests.
+      #
+      # ## Parameters (optional):
+      # - ids [list of strings, default nil]: list of LedgerLog ids to filter retrieved objects. ex: ['5656565656565656', '4545454545454545']
+      # - limit [integer, default 100]: maximum number of objects to be retrieved. Max = 100. ex: 35
+      # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+      # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+      # - ledger_id [string, default nil]: filter logs by Ledger id. ex: '5656565656565656'
+      # - cursor [string, default nil]: cursor returned on the previous page function call
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+      #
+      # ## Return:
+      # - list of Ledger::Log objects with updated attributes
+      # - cursor to retrieve the next page of Ledger::Log objects
+      def self.page(ids: nil, limit: nil, after: nil, before: nil, ledger_id: nil, cursor: nil, user: nil)
+        after = StarkCore::Utils::Checks.check_date(after)
+        before = StarkCore::Utils::Checks.check_date(before)
+        StarkInfra::Utils::Rest.get_page(
+          cursor: cursor,
+          ids: ids,
+          limit: limit,
+          after: after,
+          before: before,
+          ledger_id: ledger_id,
+          user: user,
+          **resource
+        )
+      end
+
+      def self.resource
+        request_maker = StarkInfra::Ledger.resource[:resource_maker]
+        {
+          resource_name: 'LedgerLog',
+          resource_maker: proc { |json|
+            Log.new(
+              id: json['id'],
+              created: json['created'],
+              type: json['type'],
+              ledger: StarkCore::Utils::API.from_api_json(request_maker, json['ledger'])
+            )
+          }
+        }
+      end
+    end
+  end
+end

data/lib/ledger/rule.rb

@@ -0,0 +1,55 @@
+require_relative('../utils/rest')
+
+module StarkInfra
+  class Ledger
+    # # Ledger::Rule object
+    #
+    # The Ledger::Rule object modifies the behavior of Ledger objects when passed as an argument upon their creation or update.
+    #
+    # ## Parameters (required):
+    # - key [string]: Rule to be customized, describes what Ledger behavior will be altered. ex: 'minimumBalance', 'maximumBalance'
+    # - value [integer]: Value of the rule. ex: 1000
+    class Rule < StarkCore::Utils::SubResource
+      attr_reader :key, :value
+      def initialize(key:, value:)
+        @key = key
+        @value = value
+      end
+
+      # # Parse Ledger::Rules
+      #
+      # Converts a list of hashes (or Rule objects) received from the API into a list of Ledger::Rule objects.
+      #
+      # ## Parameters (required):
+      # - rules [list of hashes or Ledger::Rule objects]: list to be parsed.
+      #
+      # ## Return:
+      # - list of parsed Ledger::Rule objects
+      def self.parse_rules(rules)
+        resource_maker = StarkInfra::Ledger::Rule.resource[:resource_maker]
+        return rules if rules.nil?
+
+        parsed_rules = []
+        rules.each do |rule|
+          unless rule.is_a? Rule
+            rule = StarkCore::Utils::API.from_api_json(resource_maker, rule)
+          end
+          parsed_rules << rule
+        end
+        return parsed_rules
+      end
+
+      def self.resource
+      {
+        resource_name: 'Rule',
+        resource_maker: proc { |json|
+          Rule.new(
+            key: json['key'],
+            value: json['value']
+          )
+        }
+      }
+      end
+    end
+  end
+end

data/lib/ledger_transaction/ledger_transaction.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+require_relative('../ledger/rule')
+
+module StarkInfra
+  # # LedgerTransaction object
+  #
+  # LedgerTransactions are used to track the balance of a given amount by inserting LedgerTransactions to them.
+  # They can represent a bank account, a digital wallet, an inventory product, etc.
+  #
+  # ## Parameters (required):
+  # - amount [integer]: amount of the transaction. ex: 11234
+  # - ledger_id [string]: id of the Ledger containing the transaction. ex: '5656565656565656'
+  # - external_id [string]: string that must be unique among all your LedgerTransactions in a single Ledger. ex: 'my-internal-id-123456'
+  # - source [string]: source of the LedgerTransaction. ex: 'bank-transfer/123'
+  #
+  # ## Parameters (optional):
+  # - fee [integer]: fee applied to the LedgerTransaction. ex: 100
+  # - rules [list of Ledger::Rule objects, default []]: list of Rule objects linked to the LedgerTransaction. Rules are used to overwrite the Ledger's rules for this transaction. ex: [Ledger::Rule.new(key: 'minimumBalance', value: 0)]
+  # - metadata [dictionary, default {}]: dictionary object used to store additional information about the LedgerTransaction object. ex: { 'orderId': '123', 'orderType': 'purchase' }
+  # - tags [list of strings, default []]: list of strings for reference when searching for LedgerTransactions. ex: ['transfer/123', 'savings']
+  # - created [DateTime or string, default nil]: datetime to backdate the transaction, used to import existing transaction history. Cannot be in the future; when creating multiple transactions in one request, their created values must be in chronological order. Defaults to the current datetime when omitted.
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when the LedgerTransaction is created. ex: '5656565656565656'
+  # - balance [integer]: Ledger's balance after the transaction. ex: 11234
+  class LedgerTransaction < StarkCore::Utils::Resource
+    attr_reader :amount, :ledger_id, :external_id, :source, :id, :balance, :fee, :rules, :metadata, :tags, :created
+    def initialize(
+      amount:, ledger_id:, external_id:, source:, id: nil, balance: nil, fee: nil, rules: nil,
+      metadata: nil, tags: nil, created: nil
+    )
+      super(id)
+      @amount = amount
+      @ledger_id = ledger_id
+      @external_id = external_id
+      @source = source
+      @balance = balance
+      @fee = fee
+      @rules = StarkInfra::Ledger::Rule.parse_rules(rules)
+      @metadata = metadata
+      @tags = tags
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+    end
+
+    # # Create LedgerTransactions
+    #
+    # Send a list of LedgerTransaction objects for creation at the Stark Infra API
+    #
+    # ## Parameters (required):
+    # - transactions [list of LedgerTransaction objects]: list of LedgerTransaction objects to be created in the Stark Infra API. You can send up to 500 objects in a single request, targeting different ledgers if needed; each is applied to its Ledger in the order sent, and the resulting balance is returned for each one.
+    #
+    # ## Parameters (optional):
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - list of LedgerTransaction objects with updated attributes
+    def self.create(transactions, user: nil)
+      StarkInfra::Utils::Rest.post(entities: transactions, user: user, **resource)
+    end
+
+    # # Retrieve a specific LedgerTransaction
+    #
+    # Receive a single LedgerTransaction object previously created in the Stark Infra API by its id
+    #
+    # ## Parameters (required):
+    # - id [string]: object unique id. ex: '5656565656565656'
+    #
+    # ## Parameters (optional):
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - LedgerTransaction object with updated attributes
+    def self.get(id, user: nil)
+      StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve LedgerTransactions
+    #
+    # Receive a generator of LedgerTransaction objects previously created in the Stark Infra API
+    #
+    # ## Parameters (conditionally-required):
+    # - ledger_id [string, default nil]: id of the Ledger containing the transaction. Either ledger_id or ids must be provided. If both are sent, the query will be filtered by both. ex: '5656565656565656'
+    # - ids [list of strings, default nil]: list of LedgerTransaction ids to filter retrieved objects. Either ledger_id or ids must be provided. If both are sent, the query will be filtered by both. ex: ['5656565656565656', '4545454545454545']
+    #
+    # ## Parameters (optional):
+    # - flow [string, default nil]: direction of the transaction. ex: 'in' or 'out'
+    # - tags [list of strings, default nil]: list of tags to filter retrieved objects. ex: ['transfer/123', 'savings']
+    # - external_ids [list of strings, default nil]: list of LedgerTransaction external ids to filter retrieved objects. ex: ['my-internal-id-123456', 'my-internal-id-654321']
+    # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+    # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+    # - limit [integer, default 100, maximum 1000]: maximum number of objects to be retrieved. Unlimited if nil. ex: 35
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - generator of LedgerTransaction objects with updated attributes
+    def self.query(ledger_id: nil, flow: nil, tags: nil, external_ids: nil, after: nil, before: nil,
+                    ids: nil, limit: nil, user: nil)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
+      StarkInfra::Utils::Rest.get_stream(
+        ledger_id: ledger_id,
+        flow: flow,
+        tags: tags,
+        external_ids: external_ids,
+        after: after,
+        before: before,
+        ids: ids,
+        limit: limit,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Retrieve paged LedgerTransactions
+    #
+    # Receive a list of LedgerTransaction objects previously created in the Stark Infra API and the cursor to the next page.
+    # Use this function instead of query if you want to manually page your requests.
+    #
+    # ## Parameters (conditionally-required):
+    # - ledger_id [string, default nil]: id of the Ledger containing the transaction. Either ledger_id or ids must be provided. If both are sent, the query will be filtered by both. ex: '5656565656565656'
+    # - ids [list of strings, default nil]: list of LedgerTransaction ids to filter retrieved objects. Either ledger_id or ids must be provided. If both are sent, the query will be filtered by both. ex: ['5656565656565656', '4545454545454545']
+    #
+    # ## Parameters (optional):
+    # - flow [string, default nil]: direction of the transaction. ex: 'in' or 'out'
+    # - tags [list of strings, default nil]: list of tags to filter retrieved objects. ex: ['transfer/123', 'savings']
+    # - external_ids [list of strings, default nil]: list of LedgerTransaction external ids to filter retrieved objects. ex: ['my-internal-id-123456', 'my-internal-id-654321']
+    # - after [Date or string, default nil]: date filter for objects created only after specified date. ex: Date.new(2020, 3, 10)
+    # - before [Date or string, default nil]: date filter for objects created only before specified date. ex: Date.new(2020, 3, 10)
+    # - limit [integer, default 100, maximum 1000]: maximum number of objects to be retrieved. Unlimited if nil. ex: 35
+    # - cursor [string, default nil]: cursor returned on the previous page function call
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - list of LedgerTransaction objects with updated attributes
+    # - cursor to retrieve the next page of LedgerTransaction objects
+    def self.page(ledger_id: nil, flow: nil, tags: nil, external_ids: nil, after: nil, before: nil,
+                  ids: nil, limit: nil, cursor: nil, user: nil)
+      after = StarkCore::Utils::Checks.check_date(after)
+      before = StarkCore::Utils::Checks.check_date(before)
+      StarkInfra::Utils::Rest.get_page(
+        ledger_id: ledger_id,
+        flow: flow,
+        tags: tags,
+        external_ids: external_ids,
+        after: after,
+        before: before,
+        ids: ids,
+        limit: limit,
+        cursor: cursor,
+        user: user,
+        **resource
+      )
+    end
+
+    def self.resource
+      {
+        resource_name: 'LedgerTransaction',
+        resource_maker: proc { |json|
+          LedgerTransaction.new(
+            id: json['id'],
+            amount: json['amount'],
+            ledger_id: json['ledger_id'],
+            external_id: json['external_id'],
+            source: json['source'],
+            balance: json['balance'],
+            fee: json['fee'],
+            rules: json['rules'],
+            metadata: json['metadata'],
+            tags: json['tags'],
+            created: json['created']
+          )
+        }
+      }
+    end
+  end
+end

data/lib/merchant_category/merchant_category.rb

@@ -19,13 +19,15 @@ module StarkInfra
   # Attributes (return-only):
   # - name [string]: category's name. ex: 'Veterinary services', 'Fast food restaurants'
   # - number [string]: category's number. ex: '742', '5814'
+  # - group [string]: category's group. ex: 'pets', 'food'
   class MerchantCategory < StarkCore::Utils::SubResource
-    attr_reader :code, :type, :name, :number
-    def initialize(code:, type:, name: nil, number: nil)
+    attr_reader :code, :type, :name, :number, :group
+    def initialize(code:, type:, name: nil, number: nil, group: nil)
       @code = code
       @type = type
       @name = name
       @number = number
+      @group = group
     end
 
     # # Retrieve MerchantCategories
@@ -54,7 +56,8 @@ module StarkInfra
             code: json['code'],
             type: json['type'],
             name: json['name'],
-            number: json['number']
+            number: json['number'],
+            group: json['group']
           )
         }
       }

data/lib/pix_balance/pix_balance.rb

@@ -12,7 +12,7 @@ module StarkInfra
   # can be retrieved to see the available information.
   #
   # ## Attributes (return-only):
-  # - id [string]: unique id returned when Balance is created. ex: '5656565656565656'
+  # - id [string]: identifier of the balance. Holds the participant bank code for direct participants, or the workspace id for indirect participants.
   # - amount [integer]: current balance amount of the workspace in cents. ex: 200 (= R$ 2.00)
   # - currency [string]: currency of the current workspace. Expect others to be added eventually. ex: 'BRL'
   # - updated [DateTime]: latest update datetime for the balance. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)