starkinfra 0.5.2 → 0.7.0

data/lib/individual_account_attachment/individual_account_attachment.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+
+module StarkInfra
+  # # IndividualAccountAttachment object
+  #
+  # Supporting document (identity document, driver's license) attached to an IndividualAccountRequest
+  # for the account-approval flow. The caller uploads the raw image bytes and a MIME content type;
+  # the SDK encodes them as a data: URL before sending.
+  #
+  # When you initialize an IndividualAccountAttachment, 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 IndividualAccountAttachment. Options: 'drivers-license-front', 'drivers-license-back', 'identity-front', 'identity-back'
+  # - content [string]: raw image bytes of the picture. After encoding, becomes a data:<contentType>;base64,<payload> URL.
+  # - account_request_id [string]: id of the parent IndividualAccountRequest. ex: '5656565656565656'
+  #
+  # ## Parameters (optional):
+  # - content_type [string, default nil]: content MIME type. Consumed as input only to build the data: URL; never sent as its own wire field. ex: 'image/png' or 'image/jpeg'
+  # - tags [list of strings, default nil]: list of strings for reference when searching for IndividualAccountAttachments. ex: ['employees', 'monthly']
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when the IndividualAccountAttachment is created. ex: '5656565656565656'
+  # - status [string]: current status of the IndividualAccountAttachment. Options: 'created', 'success', 'failed', 'deleted'
+  # - created [DateTime]: creation datetime for the IndividualAccountAttachment. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class IndividualAccountAttachment < StarkCore::Utils::Resource
+    attr_reader :type, :content, :content_type, :account_request_id, :tags, :id, :status, :created
+    def initialize(type:, content:, account_request_id:, content_type: nil, tags: nil, id: nil, status: nil, created: nil)
+      super(id)
+      @type = type
+      @account_request_id = account_request_id
+      @tags = tags
+      @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
+    end
+
+    # # Create IndividualAccountAttachments
+    #
+    # Send a list of IndividualAccountAttachment objects for creation at the Stark Infra API
+    #
+    # ## Parameters (required):
+    # - attachments [list of IndividualAccountAttachment objects]: list of IndividualAccountAttachment 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 IndividualAccountAttachment objects with updated attributes
+    def self.create(attachments, user: nil)
+      StarkInfra::Utils::Rest.post(entities: attachments, user: user, **resource)
+    end
+
+    # # Retrieve a specific IndividualAccountAttachment
+    #
+    # Receive a single IndividualAccountAttachment 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:
+    # - IndividualAccountAttachment object with updated attributes
+    def self.get(id, user: nil)
+      StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve IndividualAccountAttachments
+    #
+    # Receive a generator of IndividualAccountAttachment 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 [string, default nil]: filter for status of retrieved objects. ex: 'created'
+    # - 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 IndividualAccountAttachment 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 IndividualAccountAttachments
+    #
+    # Receive a list of up to 100 IndividualAccountAttachment 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 [string, default nil]: filter for status of retrieved objects. ex: 'created'
+    # - 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 IndividualAccountAttachment objects with updated attributes
+    # - cursor to retrieve the next page of IndividualAccountAttachment 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 an IndividualAccountAttachment entity
+    #
+    # Cancel an IndividualAccountAttachment entity previously created in the Stark Infra API
+    #
+    # ## Parameters (required):
+    # - id [string]: IndividualAccountAttachment 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 IndividualAccountAttachment object
+    def self.cancel(id, user: nil)
+      StarkInfra::Utils::Rest.delete_id(id: id, user: user, **resource)
+    end
+
+    def self.resource
+      {
+        resource_name: 'IndividualAccountAttachment',
+        resource_maker: proc { |json|
+          IndividualAccountAttachment.new(
+            type: json['type'],
+            content: json['content'],
+            content_type: json['content_type'],
+            account_request_id: json['account_request_id'],
+            tags: json['tags'],
+            id: json['id'],
+            status: json['status'],
+            created: json['created']
+          )
+        }
+      }
+    end
+  end
+end

data/lib/individual_account_attachment/log.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+require_relative('individual_account_attachment')
+
+module StarkInfra
+  class IndividualAccountAttachment
+    # # IndividualAccountAttachment::Log object
+    #
+    # Every time an IndividualAccountAttachment entity is modified, a corresponding IndividualAccountAttachment::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 IndividualAccountAttachment.
+    #
+    # ## Attributes (return-only):
+    # - id [string]: unique id returned when the log is created. ex: '5656565656565656'
+    # - attachment [IndividualAccountAttachment]: IndividualAccountAttachment entity to which the log refers to.
+    # - errors [list of strings]: list of errors linked to this IndividualAccountAttachment event.
+    # - type [string]: type of the IndividualAccountAttachment event which triggered the log creation. Options: 'created', 'success', 'failed', 'deleted'
+    # - 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, :attachment, :errors, :type, :created
+      def initialize(id: nil, attachment: nil, errors: nil, type: nil, created: nil)
+        super(id)
+        @attachment = attachment
+        @errors = errors
+        @type = type
+        @created = StarkCore::Utils::Checks.check_datetime(created)
+      end
+
+      # # Retrieve a specific IndividualAccountAttachment::Log
+      #
+      # Receive a single IndividualAccountAttachment::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:
+      # - IndividualAccountAttachment::Log object with updated attributes
+      def self.get(id, user: nil)
+        StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+      end
+
+      # # Retrieve IndividualAccountAttachment::Logs
+      #
+      # Receive a generator of IndividualAccountAttachment::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. Options: 'created', 'success', 'failed', 'deleted'
+      # - attachment_ids [list of strings, default nil]: list of IndividualAccountAttachment 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 IndividualAccountAttachment::Log objects with updated attributes
+      def self.query(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(
+          limit: limit,
+          after: after,
+          before: before,
+          types: types,
+          attachment_ids: attachment_ids,
+          user: user,
+          **resource
+        )
+      end
+
+      # # Retrieve paged IndividualAccountAttachment::Logs
+      #
+      # Receive a list of up to 100 IndividualAccountAttachment::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
+      # - 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. Options: 'created', 'success', 'failed', 'deleted'
+      # - attachment_ids [list of strings, default nil]: list of IndividualAccountAttachment 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 IndividualAccountAttachment::Log objects with updated attributes
+      # - cursor to retrieve the next page of Log objects
+      def self.page(cursor: 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,
+          limit: limit,
+          after: after,
+          before: before,
+          types: types,
+          attachment_ids: attachment_ids,
+          user: user,
+          **resource
+        )
+      end
+
+      def self.resource
+        attachment_maker = StarkInfra::IndividualAccountAttachment.resource[:resource_maker]
+        {
+          resource_name: 'IndividualAccountAttachmentLog',
+          resource_maker: proc { |json|
+            Log.new(
+              id: json['id'],
+              attachment: StarkCore::Utils::API.from_api_json(attachment_maker, json['attachment']),
+              errors: json['errors'],
+              type: json['type'],
+              created: json['created']
+            )
+          }
+        }
+      end
+    end
+  end
+end

data/lib/individual_account_request/individual_account_request.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+require('starkcore')
+require_relative('../utils/rest')
+
+module StarkInfra
+  # # IndividualAccountRequest object
+  #
+  # Request to open a Stark Infra account for an individual. The caller submits the individual's
+  # identifying data and income, and the API runs the approval flow asynchronously. Supporting
+  # documents are uploaded as IndividualAccountAttachment objects referencing this request.
+  #
+  # When you initialize an IndividualAccountRequest, 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]: full legal name of the individual. ex: 'Tony Stark'
+  # - tax_id [string]: individual's Brazilian CPF. ex: '012.345.678-90' or '01234567890'
+  # - address [IndividualAccountRequest::Address object]: structured residential address.
+  # - income [integer]: monthly income in cents. Must be >= 0. ex: 1000000 (= R$ 10,000.00)
+  #
+  # ## Parameters (optional):
+  # - birth_date [Date or string, default nil]: individual's birth date. Returned as nil when not informed. ex: Date.new(2012, 3, 6) or '2012-03-06'
+  # - tags [list of strings, default nil]: list of strings for reference when searching for IndividualAccountRequests. ex: ['employees', 'monthly']
+  #
+  # ## Attributes (return-only):
+  # - id [string]: unique id returned when the IndividualAccountRequest is created. ex: '5656565656565656'
+  # - status [string]: current status of the IndividualAccountRequest. Options: 'created', 'processing', 'approved', 'denied', 'failed'
+  # - account_type [string]: account type of the request. Always 'individual' for this resource. ex: 'individual'
+  # - flags [list of hashes]: flags raised by the KYC pipeline, populated when the request is denied. Each flag has a code and a message. ex: [{ 'code' => 'bureauValidation', 'message' => '...' }]
+  # - validator_link [string]: webview link to be delivered to the taker to complete biometrics and document capture.
+  # - created [DateTime]: creation datetime for the IndividualAccountRequest. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  # - updated [DateTime]: latest update datetime for the IndividualAccountRequest. ex: DateTime.new(2020, 3, 10, 10, 30, 0, 0)
+  class IndividualAccountRequest < StarkCore::Utils::Resource
+    attr_reader :name, :tax_id, :address, :income, :birth_date, :tags, :id, :status, :account_type, :flags, :validator_link, :created, :updated
+    def initialize(
+      name:, tax_id:, address:, income:, birth_date: nil, tags: nil,
+      id: nil, status: nil, account_type: nil, flags: nil, validator_link: nil, created: nil, updated: nil
+    )
+      super(id)
+      @name = name
+      @tax_id = tax_id
+      @address = IndividualAccountRequest::Address.parse_address(address)
+      @income = income
+      @birth_date = birth_date.to_s.empty? ? nil : StarkCore::Utils::Checks.check_date(birth_date)
+      @tags = tags
+      @status = status
+      @account_type = account_type
+      @flags = flags
+      @validator_link = validator_link
+      @created = StarkCore::Utils::Checks.check_datetime(created)
+      @updated = StarkCore::Utils::Checks.check_datetime(updated)
+    end
+
+    # # Create IndividualAccountRequests
+    #
+    # Send a list of IndividualAccountRequest objects for creation at the Stark Infra API
+    #
+    # ## Parameters (required):
+    # - requests [list of IndividualAccountRequest objects]: list of IndividualAccountRequest 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 IndividualAccountRequest objects with updated attributes
+    def self.create(requests, user: nil)
+      # Output-only fields (id, status, account_type, flags, created, updated) are
+      # rejected by the API on POST with "Unknown parameters in JSON: ...". Strip
+      # them from a shallow dup so the caller's objects are unmodified. The core
+      # serializer (StarkCore::Utils::API.build_entity_hash) skips nil ivars.
+      stripped = requests.map do |req|
+        copy = req.dup
+        %i[@id @status @account_type @flags @created @updated].each do |ivar|
+          copy.instance_variable_set(ivar, nil)
+        end
+        copy
+      end
+      StarkInfra::Utils::Rest.post(entities: stripped, user: user, **resource)
+    end
+
+    # # Retrieve a specific IndividualAccountRequest
+    #
+    # Receive a single IndividualAccountRequest 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:
+    # - IndividualAccountRequest object with updated attributes
+    def self.get(id, user: nil)
+      StarkInfra::Utils::Rest.get_id(id: id, user: user, **resource)
+    end
+
+    # # Retrieve IndividualAccountRequests
+    #
+    # Receive a generator of IndividualAccountRequest 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 [string, default nil]: filter for status of retrieved objects. ex: 'created'
+    # - 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 IndividualAccountRequest 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 IndividualAccountRequests
+    #
+    # Receive a list of up to 100 IndividualAccountRequest 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 [string, default nil]: filter for status of retrieved objects. ex: 'created'
+    # - 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 IndividualAccountRequest objects with updated attributes
+    # - cursor to retrieve the next page of IndividualAccountRequest 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
+
+    # # Update an IndividualAccountRequest entity
+    #
+    # Update an IndividualAccountRequest by passing its id.
+    #
+    # ## Parameters (required):
+    # - id [string]: IndividualAccountRequest unique id. ex: '5656565656565656'
+    #
+    # ## Parameters (optional):
+    # - name [string, default nil]: replace the legal name. ex: 'Tony Stark'
+    # - tax_id [string, default nil]: replace the CPF. ex: '012.345.678-90'
+    # - address [IndividualAccountRequest::Address object, default nil]: replace the address as a whole object.
+    # - income [integer, default nil]: replace monthly income in cents. ex: 1000000
+    # - birth_date [Date or string, default nil]: replace the birth date. ex: '2012-03-06'
+    # - status [string, default nil]: manual state transition. ex: 'processing'
+    # - tags [list of strings, default nil]: replace tag list. 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 IndividualAccountRequest with updated attributes
+    def self.update(id, name: nil, tax_id: nil, address: nil, income: nil, birth_date: nil, status: nil, tags: nil, user: nil)
+      StarkInfra::Utils::Rest.patch_id(
+        id: id,
+        name: name,
+        tax_id: tax_id,
+        address: address,
+        income: income,
+        birth_date: birth_date.to_s.empty? ? nil : StarkCore::Utils::Checks.check_date(birth_date),
+        status: status,
+        tags: tags,
+        user: user,
+        **resource
+      )
+    end
+
+    def self.resource
+      {
+        resource_name: 'IndividualAccountRequest',
+        resource_maker: proc { |json|
+          IndividualAccountRequest.new(
+            id: json['id'],
+            name: json['name'],
+            tax_id: json['tax_id'],
+            address: json['address'],
+            income: json['income'],
+            birth_date: json['birth_date'],
+            tags: json['tags'],
+            status: json['status'],
+            account_type: json['account_type'],
+            flags: json['flags'],
+            validator_link: json['validator_link'],
+            created: json['created'],
+            updated: json['updated']
+          )
+        }
+      }
+    end
+
+    # # IndividualAccountRequest::Address object
+    #
+    # Structured residential address embedded as the `address` field on an IndividualAccountRequest.
+    # Serialized as a nested JSON object on the wire (never flattened).
+    #
+    # ## Parameters (required):
+    # - street [string]: street name. ex: 'Rua do Estilo Barroco'
+    # - number [string]: street number. ex: '648'
+    # - neighborhood [string]: neighborhood / district. ex: 'Santo Amaro'
+    # - city [string]: city. ex: 'SP'
+    # - state [string]: state (BR 2-letter code). ex: 'SP'
+    # - zip_code [string]: ZIP code (BR CEP). ex: '05724005'
+    #
+    # ## Parameters (optional):
+    # - complement [string, default nil]: address complement. ex: 'Apto. 123'
+    class Address < StarkCore::Utils::SubResource
+      attr_reader :street, :number, :neighborhood, :city, :state, :zip_code, :complement
+      def initialize(street: nil, number: nil, neighborhood: nil, city: nil, state: nil, zip_code: nil, complement: nil)
+        @street = street
+        @number = number
+        @neighborhood = neighborhood
+        @city = city
+        @state = state
+        @zip_code = zip_code
+        @complement = complement
+      end
+
+      def self.parse_address(address)
+        return address if address.nil? || address.is_a?(IndividualAccountRequest::Address)
+
+        StarkCore::Utils::API.from_api_json(resource[:resource_maker], address)
+      end
+
+      def self.resource
+        {
+          resource_name: 'Address',
+          resource_maker: proc { |json|
+            Address.new(
+              street: json['street'],
+              number: json['number'],
+              neighborhood: json['neighborhood'],
+              city: json['city'],
+              state: json['state'],
+              zip_code: json['zip_code'],
+              complement: json['complement']
+            )
+          }
+        }
+      end
+    end
+  end
+end