starkinfra 0.5.2 → 0.7.0

data/lib/business_attachment/business_attachment.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+require_relative('../utils/parse')
+
+module StarkInfra
+  # # BusinessAttachment object
+  #
+  # Business attachments are files containing documents of a company that must be attached to a business
+  # identity to be used for its validation.
+  #
+  # When you initialize a BusinessAttachment, 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):
+  # - name [string]: name of the BusinessAttachment. ex: "articles-of-incorporation.pdf"
+  # - content [string]: Base64 data url of the file or its raw bytes on creation; when retrieved via get, populated only when expand: ['content'] is passed, nil otherwise. ex: data:application/pdf;base64,JVBERi0xLjQ...
+  # - business_identity_id [string]: Unique id of BusinessIdentity. ex: "5656565656565656"
+  #
+  # ## Parameters (optional):
+  # - content_type [string, default nil]: content MIME type. This parameter is required as input only. ex: "image/png" or "application/pdf"
+  # - tags [list of strings, default nil]: list of strings for reference when searching for BusinessAttachments. ex: ["employees", "monthly"]
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when the BusinessAttachment is created. ex: "5656565656565656"
+  # - attachment_id [string]: Unique id of the attached file. ex: "5656565656565656"
+  # - status [string]: current status of the BusinessAttachment. Options: "created", "canceled", "approved", "denied"
+  # - created [DateTime]: creation datetime for the BusinessAttachment. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - updated [DateTime]: latest update datetime for the BusinessAttachment. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class BusinessAttachment < StarkCore::Utils::Resource
+    attr_reader :name, :content, :content_type, :business_identity_id, :tags, :id, :attachment_id, :status, :created, :updated
+    def initialize(name:, content:, business_identity_id:, content_type: nil, tags: nil, id: nil, attachment_id: nil,
+                   status: nil, created: nil, updated: nil)
+      super(id)
+      @name = name
+      @business_identity_id = business_identity_id
+      @tags = tags
+      @attachment_id = attachment_id
+      @status = status
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
+      @content = content
+      @content_type = content_type
+
+      if @content_type
+        @content = "data:#{content_type};base64,#{Base64.encode64(content)}"
+        @content_type = nil
+      end
+    end
+
+    # # Create BusinessAttachments
+    #
+    # Send a list of BusinessAttachment objects for creation at the Stark Infra API. Limit of 1 attachment per
+    # request and 2 attachments per identity. Only PDF, JPG and PNG files are accepted, up to 8 MB each; name
+    # must be unique among the identity's other 'created' attachments; the identity must be in 'created'/'pending'
+    # status with fewer than 2 attachments already.
+    #
+    # ## Parameters (required):
+    # - attachments [list of BusinessAttachment objects]: list of BusinessAttachment 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 BusinessAttachment objects with updated attributes
+    def self.create(attachments, user: nil)
+      StarkInfra::Utils::Rest.post(entities: attachments, user: user, **resource)
+    end
+
+    # # Retrieve a specific BusinessAttachment
+    #
+    # Receive a single BusinessAttachment object previously created in the Stark Infra API by its id
+    #
+    # ## Parameters (required):
+    # - id [string]: object unique id. ex: "5656565656565656"
+    #
+    # ## Parameters (optional):
+    # - expand [list of strings, default nil]: fields to expand information. ex: ["content"]
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkinfra.user was set before function call
+    #
+    # ## Return:
+    # - BusinessAttachment object with updated attributes
+    def self.get(id, expand: nil, user: nil)
+      StarkInfra::Utils::Rest.get_id(id: id, expand: expand, user: user, **resource)
+    end
+
+    # # Retrieve BusinessAttachments
+    #
+    # Receive a generator of BusinessAttachment 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", "approved", "denied"]
+    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ['tony', 'stark']
+    # - 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 BusinessAttachment 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)
+      StarkInfra::Utils::Rest.get_stream(
+        limit: limit,
+        after: after,
+        before: before,
+        status: status,
+        tags: tags,
+        ids: ids,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Retrieve paged BusinessAttachments
+    #
+    # Receive a list of up to 100 BusinessAttachment 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. Options: ["created", "canceled", "approved", "denied"]
+    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ['tony', 'stark']
+    # - 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 BusinessAttachment objects with updated attributes
+    # - cursor to retrieve the next page of BusinessAttachment 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)
+      StarkInfra::Utils::Rest.get_page(
+        cursor: cursor,
+        limit: limit,
+        after: after,
+        before: before,
+        status: status,
+        tags: tags,
+        ids: ids,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Cancel a BusinessAttachment entity
+    #
+    # Cancel a BusinessAttachment entity previously created in the Stark Infra API. Only attachments in 'created' status can be canceled.
+    #
+    # ## Parameters (required):
+    # - id [string]: BusinessAttachment 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:
+    # - canceled BusinessAttachment object
+    def self.cancel(id, user: nil)
+      StarkInfra::Utils::Rest.delete_id(id: id, user: user, **resource)
+    end
+
+    def self.resource
+      {
+        resource_name: 'BusinessAttachment',
+        resource_maker: proc { |json|
+          BusinessAttachment.new(
+            name: json['name'],
+            content: json['content'],
+            content_type: json['content_type'],
+            business_identity_id: json['business_identity_id'],
+            tags: json['tags'],
+            id: json['id'],
+            attachment_id: json['attachment_id'],
+            status: json['status'],
+            created: json['created'],
+            updated: json['updated']
+          )
+        }
+      }
+    end
+  end
+end

data/lib/{individual_document → business_attachment}/log.rb

@@ -2,34 +2,34 @@
 
 require('starkcore')
 require_relative('../utils/rest')
-require_relative('individual_document')
+require_relative('business_attachment')
 
 module StarkInfra
-  class IndividualDocument
-    # # IndividualDocument::Log object
+  class BusinessAttachment
+    # # BusinessAttachment::Log object
     #
-    # Every time an IndividualDocument entity is updated, a corresponding IndividualDocument::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 IndividualDocument.
+    # Every time a BusinessAttachment entity is updated, a corresponding BusinessAttachment::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 BusinessAttachment.
     #
     # ## Attributes (return-only):
     # - id [string]: unique id returned when the log is created. ex: '5656565656565656'
-    # - document [IndividualDocument]: IndividualDocument entity to which the log refers to.
-    # - errors [list of strings]: list of errors linked to this IndividualDocument event
-    # - type [string]: type of the IndividualDocument event which triggered the log creation. ex: 'approved', 'canceled', 'confirmed', 'denied', 'reversed', 'voided'.
+    # - attachment [BusinessAttachment]: BusinessAttachment entity to which the log refers to.
+    # - errors [list of strings]: list of errors linked to this BusinessAttachment event
+    # - type [string]: type of the BusinessAttachment event which triggered the log creation. ex: 'created', 'canceled', 'approved', 'denied'.
     # - 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, :document, :errors, :type, :created
-      def initialize(id: nil, document: nil, errors: nil, type: nil, created: nil)
+      attr_reader :id, :attachment, :errors, :type, :created
+      def initialize(id: nil, attachment: nil, errors: nil, type: nil, created: nil)
         super(id)
-        @document = document
+        @attachment = attachment
         @errors = errors
         @type = type
         @created = StarkCore::Utils::Checks.check_datetime(created)
       end
 
-      # # Retrieve a specific IndividualDocument::Log
+      # # Retrieve a specific BusinessAttachment::Log
       #
-      # Receive a single IndividualDocument::Log object previously created by the Stark Infra API by passing its id
+      # Receive a single BusinessAttachment::Log object previously created by the Stark Infra API by passing its id
       #
       # ## Parameters (required):
       # - id [string]: object unique id. ex: '5656565656565656'
@@ -38,26 +38,27 @@ module StarkInfra
       # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
       #
       # ## Return:
-      # - IndividualDocument::Log object with updated attributes
+      # - BusinessAttachment::Log object with updated attributes
       def self.get(id, user: nil)
         StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
       end
 
-      # # Retrieve IndividualDocument::Logs
+      # # Retrieve BusinessAttachment::Logs
       #
-      # Receive a generator of IndividualDocument::Log objects previously created in the Stark Infra API
+      # Receive a generator of BusinessAttachment::Log 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)
-      # - types [list of strings, default nil]: filter for log event types. ex: ['created', 'canceled', 'processing', 'failed', 'success']
-      # - document_ids [list of strings, default nil]: list of IndividualDocument ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - types [list of strings, default nil]: filter for log event types. ex: ['created', 'canceled', 'approved', 'denied']
+      # - attachment_ids [list of strings, default nil]: list of BusinessAttachment ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - ids [list of strings, default nil]: Log ids to filter BusinessAttachment Logs. 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 IndividualDocument::Log objects with updated attributes
-      def self.query(ids: nil, limit: nil, after: nil, before: nil, types: nil, document_ids: nil, user: nil)
+      # - generator of BusinessAttachment::Log objects with updated attributes
+      def self.query(ids: nil, limit: nil, after: nil, before: nil, types: nil, attachment_ids: nil, user: nil)
         after = StarkCore::Utils::Checks.check_date(after)
         before = StarkCore::Utils::Checks.check_date(before)
         StarkInfra::Utils::Rest.get_stream(
@@ -66,52 +67,54 @@ module StarkInfra
           after: after,
           before: before,
           types: types,
-          document_ids: document_ids,
+          attachment_ids: attachment_ids,
           user: user,
           **resource
         )
       end
 
-      # # Retrieve paged IndividualDocument::Logs
+      # # Retrieve paged BusinessAttachment::Logs
       #
-      # Receive a list of up to 100 IndividualDocument::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 documents.
+      # Receive a list of up to 100 BusinessAttachment::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 attachments.
       #
       # ## 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)
-      # - types [list of strings, default nil]: filter for log event types. ex: ['created', 'canceled', 'processing', 'failed', 'success']
-      # - document_ids [list of strings, default nil]: list of document ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - types [list of strings, default nil]: filter for log event types. ex: ['created', 'canceled', 'approved', 'denied']
+      # - attachment_ids [list of strings, default nil]: list of attachment ids to filter logs. ex: ['5656565656565656', '4545454545454545']
+      # - ids [list of strings, default nil]: Log ids to filter BusinessAttachment Logs. ex: ['5656565656565656']
       # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkinfra.user was set before function call
       #
       # ## Return:
-      # - list of IndividualDocument::Log objects with updated attributes
+      # - list of BusinessAttachment::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, document_ids: nil, user: nil)
+      def self.page(cursor: nil, ids: nil, limit: nil, after: nil, before: nil, types: nil, attachment_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,
-          document_ids: document_ids,
+          attachment_ids: attachment_ids,
           user: user,
           **resource
         )
       end
 
       def self.resource
-        request_maker = StarkInfra::IndividualDocument.resource[:resource_maker]
+        request_maker = StarkInfra::BusinessAttachment.resource[:resource_maker]
         {
-          resource_name: 'IndividualDocumentLog',
+          resource_name: 'BusinessAttachmentLog',
           resource_maker: proc { |json|
             Log.new(
               id: json['id'],
-              document: StarkCore::Utils::API.from_api_json(request_maker, json['document']),
+              attachment: StarkCore::Utils::API.from_api_json(request_maker, json['attachment']),
               errors: json['errors'],
               type: json['type'],
               created: json['created']

data/lib/business_identity/business_identity.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+require_relative('../utils/parse')
+
+module StarkInfra
+  # # BusinessIdentity object
+  #
+  # A BusinessIdentity represents a company to be validated. It can have several business attachments
+  # attached to it, which are used to validate the identity of the company. Once a business identity is created,
+  # business attachments must be attached to it using the created method of the business attachment resource. When all
+  # the required business attachments are attached to a business identity it can be sent to validation by patching its
+  # status to processing.
+  #
+  # When you initialize a BusinessIdentity, 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):
+  # - tax_id [string]: company's tax ID (CNPJ). ex: "20.018.183/0001-80"
+  #
+  # ## Parameters (optional):
+  # - tags [list of strings, default nil]: list of strings for reference when searching for BusinessIdentities. ex: ["employees", "monthly"]
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when the BusinessIdentity is created. ex: "5656565656565656"
+  # - name [string]: company's full name. ex: "Stark Bank S.A."
+  # - tax_id_status [string]: bureau status of the CNPJ, normalized from the Receita Federal value. Options: 'active' (ATIVA), 'blocked' (SUSPENSA), 'pending' (INAPTA), 'canceled' (BAIXADA), 'voided' (NULA).
+  # - insight_tax_id [string]: tax ID returned by the validation insight. ex: "20018183000180"
+  # - insight_document_type [string]: document type returned by the validation insight. ex: "cnpj"
+  # - num_pages [integer]: number of pages of the attached documents. ex: 3
+  # - representatives [string]: JSON string with the company's representatives.
+  # - attachments [list of strings]: list of BusinessAttachment ids attached to the BusinessIdentity. ex: ["5656565656565656", "4545454545454545"]
+  # - rules [string]: JSON string with the validation rules.
+  # - status [string]: current status of the BusinessIdentity. Options: "created", "pending", "canceled", "processing", "success", "failed"
+  # - created [DateTime]: creation datetime for the BusinessIdentity. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - updated [DateTime]: latest update datetime for the BusinessIdentity. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class BusinessIdentity < StarkCore::Utils::Resource
+    attr_reader :tax_id, :tags, :id, :name, :tax_id_status, :insight_tax_id, :insight_document_type, :num_pages,
+                :representatives, :attachments, :rules, :status, :created, :updated
+    def initialize(tax_id:, tags: nil, id: nil, name: nil, tax_id_status: nil, insight_tax_id: nil,
+                   insight_document_type: nil, num_pages: nil, representatives: nil, attachments: nil, rules: nil,
+                   status: nil, created: nil, updated: nil)
+      super(id)
+      @tax_id = tax_id
+      @tags = tags
+      @name = name
+      @tax_id_status = tax_id_status
+      @insight_tax_id = insight_tax_id
+      @insight_document_type = insight_document_type
+      @num_pages = num_pages
+      @representatives = representatives
+      @attachments = attachments
+      @rules = rules
+      @status = status
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
+    end
+
+    # # Create BusinessIdentities
+    #
+    # Send a list of BusinessIdentity objects for creation at the Stark Infra API. Each entry is created in
+    # 'pending' status. The CNPJ must be valid, active in the official bureau, and return non-empty
+    # representatives (sócios), or the request fails.
+    #
+    # ## Parameters (required):
+    # - identities [list of BusinessIdentity objects]: list of BusinessIdentity 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 BusinessIdentity objects with updated attributes
+    def self.create(identities, user: nil)
+      StarkInfra::Utils::Rest.post(entities: identities, user: user, **resource)
+    end
+
+    # # Retrieve a specific BusinessIdentity
+    #
+    # Receive a single BusinessIdentity 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:
+    # - BusinessIdentity object with updated attributes
+    def self.get(uuid, user: nil)
+      StarkInfra::Utils::Rest.get_id(id: uuid, user: user, **resource)
+    end
+
+    # # Retrieve BusinessIdentities
+    #
+    # Receive a generator of BusinessIdentity 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: ["created", "pending", "canceled", "processing", "success", "failed"]
+    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ['tony', 'stark']
+    # - ids [list of strings, default nil]: list of ids to filter retrieved objects. ex: ["5656565656565656", "4545454545454545"]
+    # - tax_ids [list of strings, default nil]: list of tax ids to filter retrieved objects. ex: ["20.018.183/0001-80"]
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - generator of BusinessIdentity objects with updated attributes
+    def self.query(limit: nil, after: nil, before: nil, status: nil, tags: nil, ids: nil, tax_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,
+        tags: tags,
+        ids: ids,
+        tax_ids: tax_ids,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Retrieve paged BusinessIdentities
+    #
+    # Receive a list of up to 100 BusinessIdentity 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: ["created", "pending", "canceled", "processing", "success", "failed"]
+    # - tags [list of strings, default nil]: tags to filter retrieved objects. ex: ['tony', 'stark']
+    # - ids [list of strings, default nil]: list of ids to filter retrieved objects. ex: ["5656565656565656", "4545454545454545"]
+    # - tax_ids [list of strings, default nil]: list of tax ids to filter retrieved objects. ex: ["20.018.183/0001-80"]
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if StarkInfra.user was set before function call
+    #
+    # ## Return:
+    # - list of BusinessIdentity objects with updated attributes
+    # - cursor to retrieve the next page of BusinessIdentity objects
+    def self.page(cursor: nil, limit: nil, after: nil, before: nil, status: nil, tags: nil, ids: nil, tax_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,
+        tags: tags,
+        ids: ids,
+        tax_ids: tax_ids,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Update BusinessIdentity entity
+    #
+    # Update a BusinessIdentity by passing id.
+    #
+    # ## Parameters (required):
+    # - id [string]: BusinessIdentity unique id. ex: '5656565656565656'
+    #
+    # ## Parameters (optional):
+    # - status [string, default nil]: only 'processing' is accepted, triggering the AI Model analysis. The identity must be in 'created'/'pending' status and already have at least one BusinessAttachment associated with it.
+    # - tags [list of strings, default nil]: list of strings for reference when searching for BusinessIdentities. ex: ["employees", "monthly"]
+    # - user [Organization/Project object, default nil]: Organization or Project object. Not necessary if starkinfra.user was set before function call
+    #
+    # ## Return:
+    # - target BusinessIdentity with updated attributes
+    def self.update(id, status: nil, tags: nil, user: nil)
+      StarkInfra::Utils::Rest.patch_id(
+        id: id,
+        status: status,
+        tags: tags,
+        user: user,
+        **resource
+      )
+    end
+
+    # # Cancel a BusinessIdentity entity
+    #
+    # Cancel a BusinessIdentity entity previously created in the Stark Infra API. Only identities in 'created'
+    # or 'pending' status can be canceled.
+    #
+    # ## Parameters (required):
+    # - id [string]: BusinessIdentity 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:
+    # - canceled BusinessIdentity object
+    def self.cancel(id, user: nil)
+      StarkInfra::Utils::Rest.delete_id(id: id, user: user, **resource)
+    end
+
+    def self.resource
+      {
+        resource_name: 'BusinessIdentity',
+        resource_maker: proc { |json|
+          BusinessIdentity.new(
+            tax_id: json['tax_id'],
+            tags: json['tags'],
+            id: json['id'],
+            name: json['name'],
+            tax_id_status: json['tax_id_status'],
+            insight_tax_id: json['insight_tax_id'],
+            insight_document_type: json['insight_document_type'],
+            num_pages: json['num_pages'],
+            representatives: json['representatives'],
+            attachments: json['attachments'],
+            rules: json['rules'],
+            status: json['status'],
+            created: json['created'],
+            updated: json['updated']
+          )
+        }
+      }
+    end
+  end
+end