starkinfra 0.5.2 → 0.7.0

data/lib/pix_internal_transaction_report/pix_internal_transaction_report.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+
+
+module StarkInfra
+  # # PixInternalTransactionReport object
+  #
+  # Transactions that happen internally — outside of the SPI — must be reported to
+  # the Central Bank so they are reflected in the participant's statements. A
+  # PixInternalTransactionReport is the report you create for each such transaction.
+  #
+  # When you initialize a PixInternalTransactionReport, the entity will not be
+  # automatically created in the Stark Infra API. The 'create' function sends the
+  # objects to the Stark Infra API and returns the list of created objects.
+  #
+  # ## Parameters (required):
+  # - amount [integer]: amount in cents of the reported transaction. ex: 1234 (= R$ 12.34)
+  # - created [DateTime or string]: datetime when the reported transaction occurred. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - end_to_end_id [string]: central bank's unique transaction id. ex: 'E20018183202201201213u34sav898j'
+  # - method [string]: execution method of the transaction. ex: 'contactless', 'dict', 'dynamicQrcode', 'initiator', 'manual', 'payerQrcode', 'staticContactless', 'staticQrcode' or 'subscription'
+  # - reference_type [string]: type of the reported transaction. ex: 'request' or 'reversal'
+  # - sender_account_number [string]: sender's bank account number. ex: '876543-2'
+  # - sender_branch_code [string]: sender's bank account branch code. ex: '1357-9'
+  # - sender_account_type [string]: sender's bank account type. ex: 'checking', 'savings', 'salary' or 'payment'
+  # - sender_bank_code [string]: sender's participant code (ISPB). ex: '20018183'
+  # - sender_tax_id [string]: sender's tax ID (CPF or CNPJ) with or without formatting. ex: '01234567890' or '20.018.183/0001-80'
+  # - receiver_account_number [string]: receiver's bank account number. ex: '876543-2'
+  # - receiver_branch_code [string]: receiver's bank account branch code. ex: '1357-9'
+  # - receiver_account_type [string]: receiver's bank account type. ex: 'checking', 'savings', 'salary' or 'payment'
+  # - receiver_bank_code [string]: receiver's participant code (ISPB). ex: '20018183'
+  # - receiver_tax_id [string]: receiver's tax ID (CPF or CNPJ) with or without formatting. ex: '01234567890' or '20.018.183/0001-80'
+  #
+  # ## Parameters (conditionally-required):
+  # - return_id [string, default nil]: central bank's unique reversal id. Required when reference_type is 'reversal'. ex: 'D20018183202201201213u34sav898j'
+  #
+  # ## Parameters (optional):
+  # - receiver_key_id [string, default nil]: receiver's Pix key. ex: '+5511989898989'
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when the PixInternalTransactionReport is created. ex: '5656565656565656'
+  # - status [string]: current PixInternalTransactionReport status. Options: 'created', 'processing', 'success', 'failed'.
+  # - updated [DateTime]: latest update datetime for the PixInternalTransactionReport. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class PixInternalTransactionReport < StarkCore::Utils::Resource
+    attr_reader :amount, :created, :end_to_end_id, :method, :reference_type, :sender_account_number,
+                :sender_branch_code, :sender_account_type, :sender_bank_code, :sender_tax_id,
+                :receiver_account_number, :receiver_branch_code, :receiver_account_type, :receiver_bank_code,
+                :receiver_tax_id, :receiver_key_id, :return_id, :id, :status, :updated
+    def initialize(
+      amount:, created:, end_to_end_id:, method:, reference_type:, sender_account_number:, sender_branch_code:,
+      sender_account_type:, sender_bank_code:, sender_tax_id:, receiver_account_number:, receiver_branch_code:,
+      receiver_account_type:, receiver_bank_code:, receiver_tax_id:, receiver_key_id: nil, return_id: nil,
+      id: nil, status: nil, updated: nil
+    )
+      super(id)
+      @amount = amount
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+      @end_to_end_id = end_to_end_id
+      @method = method
+      @reference_type = reference_type
+      @sender_account_number = sender_account_number
+      @sender_branch_code = sender_branch_code
+      @sender_account_type = sender_account_type
+      @sender_bank_code = sender_bank_code
+      @sender_tax_id = sender_tax_id
+      @receiver_account_number = receiver_account_number
+      @receiver_branch_code = receiver_branch_code
+      @receiver_account_type = receiver_account_type
+      @receiver_bank_code = receiver_bank_code
+      @receiver_tax_id = receiver_tax_id
+      @receiver_key_id = receiver_key_id
+      @return_id = return_id
+      @status = status
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
+    end
+
+    # # Create PixInternalTransactionReports
+    #
+    # Send a list of PixInternalTransactionReport objects for creation in the Stark Infra API
+    #
+    # ## Parameters (required):
+    # - reports [list of PixInternalTransactionReport objects]: list of PixInternalTransactionReport objects to be created in the API
+    #
+    # ## 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 PixInternalTransactionReport objects with updated attributes
+    def self.create(reports, user: nil)
+      StarkInfra::Utils::Rest.post(entities: reports, user: user, **resource)
+    end
+
+    # # Retrieve a specific PixInternalTransactionReport
+    #
+    # Receive a single PixInternalTransactionReport object previously created in the Stark Infra API by passing 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:
+    # - PixInternalTransactionReport object with updated attributes
+    def self.get(id, user: nil)
+      StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve PixInternalTransactionReports
+    #
+    # Receive a generator of PixInternalTransactionReport 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)
+    # - status [list of strings, default nil]: filter for status of retrieved objects. ex: ['success'] or ['sent', 'failed']
+    # - ids [list of strings, default nil]: list of ids to filter retrieved objects. ex: ['5656565656565656', '4545454545454545']
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - generator of PixInternalTransactionReport objects with updated attributes
+    def self.query(limit: nil, after: nil, before: nil, status: nil, ids: 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,
+        status: status,
+        ids: ids,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Retrieve paged PixInternalTransactionReports
+    #
+    # Receive a list of up to 100 PixInternalTransactionReport 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)
+    # - status [list of strings, default nil]: filter for status of retrieved objects. ex: ['success'] or ['sent', 'failed']
+    # - ids [list of strings, default nil]: list of ids to filter retrieved objects. ex: ['5656565656565656', '4545454545454545']
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - list of PixInternalTransactionReport objects with updated attributes
+    # - cursor to retrieve the next page of PixInternalTransactionReport objects
+    def self.page(cursor: nil, limit: nil, after: nil, before: nil, status: nil, ids: 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,
+        status: status,
+        ids: ids,
+        user: user,
+        **resource
+      )
+    end
+
+    def self.resource
+      {
+        resource_name: 'PixInternalTransactionReport',
+        resource_maker: proc { |json|
+          PixInternalTransactionReport.new(
+            id: json['id'],
+            amount: json['amount'],
+            created: json['created'],
+            end_to_end_id: json['end_to_end_id'],
+            method: json['method'],
+            reference_type: json['reference_type'],
+            sender_account_number: json['sender_account_number'],
+            sender_branch_code: json['sender_branch_code'],
+            sender_account_type: json['sender_account_type'],
+            sender_bank_code: json['sender_bank_code'],
+            sender_tax_id: json['sender_tax_id'],
+            receiver_account_number: json['receiver_account_number'],
+            receiver_branch_code: json['receiver_branch_code'],
+            receiver_account_type: json['receiver_account_type'],
+            receiver_bank_code: json['receiver_bank_code'],
+            receiver_tax_id: json['receiver_tax_id'],
+            receiver_key_id: json['receiver_key_id'],
+            return_id: json['return_id'],
+            status: json['status'],
+            updated: json['updated']
+          )
+        }
+      }
+    end
+  end
+end

data/lib/pix_key/pix_key.rb

@@ -16,7 +16,7 @@ module StarkInfra
   # ## Parameters (required):
   # - account_created [DateTime or string]: opening Date or DateTime for the linked account. ex: '2020-03-10T10:30:00.000000+00:00' or DateTime.new(2020, 3, 10, 10, 30, 0, 0).
   # - account_number [string]: number of the linked account. ex: '76543'.
-  # - account_type [string]: type of the linked account. Options: 'checking', 'savings', 'salary' or 'payment'.
+  # - account_type [string]: type of the linked account. Options: 'checking', 'savings', 'salary', 'payment', 'other'.
   # - branch_code [string]: branch code of the linked account. ex: '1234'.
   # - name [string]: holder's name of the linked account. ex: 'Jamie Lannister'.
   # - tax_id [string]: holder's taxId (CPF/CNPJ) of the linked account. ex: '012.345.678-90'.

data/lib/pix_key_holmes/log.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+require_relative('pix_key_holmes')
+
+module StarkInfra
+  class PixKeyHolmes
+    # # PixKeyHolmes::Log object
+    #
+    # Every time a PixKeyHolmes entity is updated, a corresponding PixKeyHolmes::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 PixKeyHolmes.
+    #
+    # ## Attributes (return-only):
+    # - id [string]: unique id returned when the log is created. ex: '5656565656565656'
+    # - holmes [PixKeyHolmes]: PixKeyHolmes entity to which the log refers to.
+    # - errors [list of strings]: list of errors linked to this PixKeyHolmes event.
+    # - type [string]: type of the PixKeyHolmes event which triggered the log creation. ex: 'solving', 'solved'
+    # - created [DateTime]: creation datetime for the log. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+    class Log < StarkCore::Utils::Resource
+      attr_reader :id, :created, :type, :errors, :holmes
+      def initialize(id:, created:, type:, errors:, holmes:)
+        super(id)
+        @holmes = holmes
+        @errors = errors
+        @type = type
+        @created = StarkCore::Utils::Checks.check_datetime(created)
+      end
+
+      # # Retrieve a specific PixKeyHolmes::Log
+      #
+      # Receive a single PixKeyHolmes::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:
+      # - PixKeyHolmes::Log object with updated attributes
+      def self.get(id, user: nil)
+        StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+      end
+
+      # # Retrieve PixKeyHolmes::Logs
+      #
+      # Receive a generator of PixKeyHolmes::Log objects previously created in the Stark Infra API
+      #
+      # ## Parameters (optional):
+      # - ids [list of strings, default nil]: list of 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)
+      # - types [list of strings, default nil]: filter for log event types. ex: ['solving', 'solved']
+      # - holmes_ids [list of strings, default nil]: list of PixKeyHolmes ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+      #
+      # ## Return:
+      # - generator of PixKeyHolmes::Log objects with updated attributes
+      def self.query(ids: nil, limit: nil, after: nil, before: nil, types: nil, holmes_ids: 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,
+          types: types,
+          holmes_ids: holmes_ids,
+          user: user,
+          **resource
+        )
+      end
+
+      # # Retrieve paged PixKeyHolmes::Logs
+      #
+      # Receive a list of up to 100 PixKeyHolmes::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):
+      # - cursor [string, default nil]: cursor returned on the previous page function call
+      # - ids [list of strings, default nil]: list of 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)
+      # - types [list of strings, default nil]: filter for log event types. ex: ['solving', 'solved']
+      # - holmes_ids [list of strings, default nil]: list of PixKeyHolmes ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+      #
+      # ## Return:
+      # - list of PixKeyHolmes::Log objects with updated attributes
+      # - cursor to retrieve the next page of PixKeyHolmes::Log objects
+      def self.page(cursor: nil, ids: nil, limit: nil, after: nil, before: nil, types: nil, holmes_ids: 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,
+          types: types,
+          holmes_ids: holmes_ids,
+          user: user,
+          **resource
+        )
+      end
+
+      def self.resource
+        holmes_maker = StarkInfra::PixKeyHolmes.resource[:resource_maker]
+        {
+          resource_name: 'PixKeyHolmesLog',
+          resource_maker: proc { |json|
+            Log.new(
+              id: json['id'],
+              holmes: StarkCore::Utils::API.from_api_json(holmes_maker, json['holmes']),
+              errors: json['errors'],
+              type: json['type'],
+              created: json['created']
+            )
+          }
+        }
+      end
+    end
+  end
+end

data/lib/{individual_document/individual_document.rb → pix_key_holmes/pix_key_holmes.rb}

@@ -2,97 +2,91 @@
 
 require('starkcore')
 require_relative('../utils/rest')
-require_relative('../utils/parse')
 
 module StarkInfra
-  # # IndividualDocument object
+  # # PixKeyHolmes object
   #
-  # Individual documents are images containing either side of a document or a selfie
-  # to be used in a matching validation. When created, they must be attached to an individual
-  # identity to be used for its validation.
+  # A PixKeyHolmes investigates the registration status of a Pix Key in the
+  # Central Bank's DICT. You open one per key you want to check; the API
+  # resolves it asynchronously and reports back whether the key is registered.
   #
-  # When you initialize a IndividualDocument, the entity will not be automatically
+  # When you initialize a PixKeyHolmes, the entity will not be automatically
   # created in the Stark Infra API. The 'create' function sends the objects
   # to the Stark Infra API and returns the list of created objects.
   #
   # ## Parameters (required):
-  # - type [string]: type of the IndividualDocument. Options: "drivers-license-front", "drivers-license-back", "identity-front", "identity-back" or "selfie"
-  # - content [string]: Base64 data url of the picture. ex: data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAASABIAAD...
-  # - content_type [string]: content MIME type. This parameter is required as input only. ex: "image/png" or "image/jpeg"
-  # - identity_id [string]: Unique id of IndividualIdentity. ex: "5656565656565656"
+  # - key_id [string]: Pix Key to be investigated. ex: "+5511989898989", "11.222.333/0001-00", "valid@sandbox.com"
   #
   # ## Parameters (optional):
-  # - tags [list of strings, default nil]: list of strings for reference when searching for IndividualDocuments. ex: ["employees", "monthly"]
+  # - tags [list of strings, default nil]: list of strings for reference when searching for PixKeyHolmes. ex: ["travel", "food"]
   #
   # ## Attributes (return-only):
-  # - id [string]: unique id returned when the IndividualDocument is created. ex: "5656565656565656"
-  # - status [string]: current status of the IndividualDocument. Options: "created", "canceled", "processing", "failed", "success"
-  # - created [DateTime]: creation datetime for the IndividualDocument. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
-  class IndividualDocument < StarkCore::Utils::Resource
-    attr_reader :type, :content, :content_type, :identity_id, :tags, :id, :status, :created 
-    def initialize(type:, content:, content_type:, identity_id:, tags: nil, id: nil, status: nil, created: nil)
+  # - id [string]: unique id returned when the PixKeyHolmes is created. ex: "5656565656565656"
+  # - result [string]: investigation result once the case is solved. ex: "registered", "unregistered"
+  # - status [string]: current status of the PixKeyHolmes. ex: "solving", "solved"
+  # - created [DateTime]: creation datetime for the PixKeyHolmes. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - updated [DateTime]: latest update datetime for the PixKeyHolmes. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class PixKeyHolmes < StarkCore::Utils::Resource
+    attr_reader :key_id, :tags, :id, :result, :status, :updated, :created
+    def initialize(key_id:, tags: nil, id: nil, result: nil, status: nil, updated: nil, created: nil)
       super(id)
-      @type = type
-      @identity_id = identity_id
+      @key_id = key_id
       @tags = tags
+      @id = id
+      @result = result
       @status = status
       @created = StarkCore::Utils::Checks.check_datetime(created)
-      @content = content
-      @content_type = content_type
-
-      if @content_type
-        @content = "data:#{content_type};base64,#{Base64.encode64(content)}"
-        @content_type = nil
-      end
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
     end
 
-    # # Create IndividualDocuments
+    # # Create PixKeyHolmes
     #
-    # Send a list of IndividualDocument objects for creation at the Stark Infra API
+    # Send a list of PixKeyHolmes objects for creation at the Stark Infra API. You can create up to 100
+    # PixKeyHolmes in a single call.
     #
     # ## Parameters (required):
-    # - documents [list of IndividualDocument objects]: list of IndividualDocument objects to be created in the API.
+    # - holmes [list of PixKeyHolmes objects]: list of PixKeyHolmes objects to be created in the API.
     #
     # ## Parameters (optional):
-    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkinfra.user was set before 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 IndividualDocument object with updated attributes
-    def self.create(documents, user: nil)
-      StarkInfra::Utils::Rest.post(entities: documents, user: user, **resource)
+    # - list of PixKeyHolmes objects with updated attributes
+    def self.create(holmes, user: nil)
+      StarkInfra::Utils::Rest.post(entities: holmes, user: user, **resource)
     end
 
-    # # Retrieve a specific IndividualDocument
+    # # Retrieve a specific PixKeyHolmes
     #
-    # Receive a single IndividualDocument object previously created in the Stark Infra API by its id
+    # Receive a single PixKeyHolmes 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
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
     #
     # ## Return:
-    # - IndividualDocument object with updated attributes
+    # - PixKeyHolmes object with updated attributes
     def self.get(id, user: nil)
       StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
     end
 
-    # # Retrieve IndividualDocuments
+    # # Retrieve PixKeyHolmes
     #
-    # Receive a generator of IndividualDocument objects previously created in the Stark Infra API
+    # Receive a generator of PixKeyHolmes 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)
-    # - status [list of strings, default nil]: filter for status of retrieved objects. Options: ["created", "canceled", "processing", "failed", "success"]
-    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ['tony', 'stark']
+    # - status [list of strings, default nil]: filter for status of retrieved objects. The live API accepts only "solved" or "solving" as filter values. ex: ["solved", "solving"]
+    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ["travel", "food"]
     # - ids [list of strings, default nil]: list of ids to filter retrieved objects. ex: ["5656565656565656", "4545454545454545"]
     # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
     #
     # ## Return:
-    # - generator of IndividualDocument objects with updated attributes
+    # - generator of PixKeyHolmes objects with updated attributes
     def self.query(limit: nil, after: nil, before: nil, status: nil, tags: nil, ids: nil, user: nil)
       after = StarkCore::Utils::Checks.check_date(after)
       before = StarkCore::Utils::Checks.check_date(before)
@@ -108,9 +102,9 @@ module StarkInfra
       )
     end
 
-    # # Retrieve paged IndividualDocuments
+    # # Retrieve PixKeyHolmes
     #
-    # Receive a list of up to 100 IndividualDocument objects previously created in the Stark Infra API and the cursor to the next page.
+    # Receive a list of up to 100 PixKeyHolmes 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):
@@ -118,14 +112,14 @@ module StarkInfra
     # - 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)
-    # - status [list of strings, default nil]: filter for status of retrieved objects. Options: ["created", "canceled", "processing", "failed", "success"]
-    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ['tony', 'stark']
+    # - status [list of strings, default nil]: filter for status of retrieved objects. The live API accepts only "solved" or "solving" as filter values. ex: ["solved", "solving"]
+    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ["travel", "food"]
     # - ids [list of strings, default nil]: list of ids to filter retrieved objects. ex: ["5656565656565656", "4545454545454545"]
     # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
     #
     # ## Return:
-    # - list of IndividualDocument objects with updated attributes
-    # - cursor to retrieve the next page of IndividualDocument objects
+    # - list of PixKeyHolmes objects with updated attributes
+    # - cursor to retrieve the next page of PixKeyHolmes objects
     def self.page(cursor: nil, limit: nil, after: nil, before: nil, status: nil, tags: nil, ids: nil, user: nil)
       after = StarkCore::Utils::Checks.check_date(after)
       before = StarkCore::Utils::Checks.check_date(before)
@@ -142,20 +136,18 @@ module StarkInfra
       )
     end
 
-
     def self.resource
       {
-        resource_name: 'IndividualDocument',
+        resource_name: 'PixKeyHolmes',
         resource_maker: proc { |json|
-          IndividualDocument.new(
-            type: json['type'],
-            content: json['content'],
-            content_type: json['content_type'],
-            identity_id: json['identity_id'],
+          PixKeyHolmes.new(
+            key_id: json['key_id'],
             tags: json['tags'],
             id: json['id'],
+            result: json['result'],
             status: json['status'],
-            created: json['created']
+            created: json['created'],
+            updated: json['updated']
           )
         }
       }

data/lib/pix_pull_request/log.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('pix_pull_request')
+require_relative('../utils/rest')
+
+module StarkInfra
+  class PixPullRequest
+    # # PixPullRequest::Log object
+    #
+    # Every time a PixPullRequest entity is modified, a corresponding PixPullRequest::Log
+    # is generated for the entity. This log is never generated by the user.
+    #
+    # ## Attributes (return-only):
+    # - id [string]: unique id returned when the log is created. ex: '5656565656565656'
+    # - request [PixPullRequest]: PixPullRequest entity to which the log refers to.
+    # - type [string]: type of the PixPullRequest event which triggered the log creation. Options: 'created', 'sent', 'scheduled', 'denied', 'success', 'canceling', 'canceled', 'expired'
+    # - errors [list of strings]: list of errors linked to this PixPullRequest event. Empty list when the type is non-failing.
+    # - created [DateTime]: creation datetime for the log. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+    class Log < StarkCore::Utils::Resource
+      attr_reader :id, :request, :type, :errors, :created
+      def initialize(id:, request:, type:, errors:, created:)
+        super(id)
+        @request = request
+        @type = type
+        @errors = errors.nil? ? [] : errors
+        @created = StarkCore::Utils::Checks.check_datetime(created)
+      end
+
+      # # Retrieve a specific PixPullRequest::Log
+      #
+      # Receive a single PixPullRequest::Log object previously created by the Stark Infra API by passing 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:
+      # - PixPullRequest::Log object with updated attributes
+      def self.get(id, user: nil)
+        StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+      end
+
+      # # Retrieve PixPullRequest::Logs
+      #
+      # Receive a generator of PixPullRequest::Log objects previously created in the Stark Infra API
+      #
+      # ## Parameters (optional):
+      # - ids [list of strings, default nil]: Log ids to filter PixPullRequest Logs. ex: ['5656565656565656']
+      # - 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)
+      # - types [list of strings, default nil]: filter retrieved objects by types. Options: 'created', 'sent', 'scheduled', 'denied', 'success', 'canceling', 'canceled', 'expired'
+      # - request_ids [list of strings, default nil]: list of PixPullRequest ids to filter retrieved objects. ex: ['5656565656565656', '4545454545454545']
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+      #
+      # ## Return:
+      # - generator of PixPullRequest::Log objects with updated attributes
+      def self.query(ids: nil, limit: nil, after: nil, before: nil, types: nil, request_ids: 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,
+          types: types,
+          request_ids: request_ids,
+          user: user,
+          **resource
+        )
+      end
+
+      # # Retrieve paged PixPullRequest::Logs
+      #
+      # Receive a list of up to 100 PixPullRequest::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):
+      # - cursor [string, default nil]: cursor returned on the previous page function call
+      # - ids [list of strings, default nil]: Log ids to filter PixPullRequest Logs. ex: ['5656565656565656']
+      # - 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)
+      # - types [list of strings, default nil]: filter retrieved objects by types. Options: 'created', 'sent', 'scheduled', 'denied', 'success', 'canceling', 'canceled', 'expired'
+      # - request_ids [list of strings, default nil]: list of PixPullRequest ids to filter retrieved objects. ex: ['5656565656565656', '4545454545454545']
+      # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+      #
+      # ## Return:
+      # - list of PixPullRequest::Log objects with updated attributes
+      # - cursor to retrieve the next page of Log objects
+      def self.page(cursor: nil, ids: nil, limit: nil, after: nil, before: nil, types: nil, request_ids: 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,
+          types: types,
+          request_ids: request_ids,
+          user: user,
+          **resource
+        )
+      end
+
+      def self.resource
+        request_maker = StarkInfra::PixPullRequest.resource[:resource_maker]
+        {
+          resource_name: 'PixPullRequestLog',
+          resource_maker: proc { |json|
+            Log.new(
+              id: json['id'],
+              request: StarkCore::Utils::API.from_api_json(request_maker, json['request']),
+              type: json['type'],
+              errors: json['errors'],
+              created: json['created']
+            )
+          }
+        }
+      end
+    end
+  end
+end