dinie-sdk-sandbox 1.1.0

data/lib/dinie/generated/resources/customers.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/multipart"
+require_relative "../../runtime/paginator"
+require_relative "../types/biometrics_session"
+require_relative "../types/credit_offer"
+require_relative "../types/customer"
+require_relative "../types/customer_bank_account"
+require_relative "../types/kyc"
+require_relative "../types/kyc_attachment_response"
+
+module Dinie
+  module Resources
+    # Operations on the customers resource.
+    class Customers
+      def initialize(http)
+        @http = http
+      end
+
+      # Register a new customer
+      #
+      # Register a new customer in `creating` status, idempotent on CPF
+      #
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def create(request_options: {}, **fields)
+        body = Customer.serialize_create(**fields)
+        raw = @http.request(method: :post, path: "/customers", body:, request_options:)
+        Customer.deserialize(raw)
+      end
+
+      # Create a biometrics capture session
+      #
+      # Generate a single-use bootstrap code for the customer-facing biometrics flow. The response includes a `session_url` the partner can embed or redirect to — the kyc-app reads the code from the URL and exchanges it for a scoped session token via `POST /biometrics/session-exchange`.
+      #
+      # @param id [String] Identificador único do cliente
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def create_biometrics_session(id, request_options: {}, **fields)
+        body = fields
+        raw = @http.request(method: :post, path: "/customers/#{id}/biometrics", body:, request_options:)
+        BiometricsSession.deserialize(raw)
+      end
+
+      # List customers
+      #
+      # List and search customers with optional filters for `cpf`, `external_id`, and `status`
+      #
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def list(limit: Internal::OMIT, starting_after: Internal::OMIT, request_options: {}, **filters)
+        fetch_page = lambda do |cursor|
+          query = { limit:, starting_after: cursor || starting_after, **filters }
+                  .reject { |_key, value| Internal.omitted?(value) }
+          body = @http.request(method: :get, path: "/customers", query:, request_options:)
+          { data: body[:data].map { |raw| Customer.deserialize(raw) }, has_more: body[:has_more] }
+        end
+        Dinie::Page.from_fetch(fetch_page)
+      end
+
+      # Retrieve a customer
+      #
+      # Return the full customer object including registration data, status, and KYC progress
+      #
+      # @param id [String] Identificador único do cliente
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def retrieve(id, request_options: {})
+        raw = @http.request(method: :get, path: "/customers/#{id}", request_options:)
+        Customer.deserialize(raw)
+      end
+
+      # Get customer bank account
+      #
+      # Return the bank account currently linked to this customer, if one exists.
+      #
+      # @param id [String] Identificador único do cliente
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def retrieve_bank_account(id, request_options: {})
+        raw = @http.request(method: :get, path: "/customers/#{id}/bank-account", request_options:)
+        CustomerBankAccount.deserialize(raw)
+      end
+
+      # Submit documents for KYC review
+      #
+      # Signal that all KYC documents have been uploaded and are ready for review. Submits documents to the verification pipeline. Also handles resubmission after document corrections.
+      #
+      # @param id [String] Identificador único do cliente
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def start_kyc_review(id, request_options: {})
+        @http.request(method: :post, path: "/customers/#{id}/kyc-review", request_options:)
+        nil
+      end
+
+      # Update customer data
+      #
+      # Update customer fields such as email or phone; `cpf`, `cnpj`, `name`, `trading_name`, and `external_id` are read-only
+      #
+      # @param id [String] Identificador único do cliente
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def update(id, request_options: {}, **fields)
+        body = Customer.serialize_update(**fields)
+        raw = @http.request(method: :patch, path: "/customers/#{id}", body:, request_options:)
+        Customer.deserialize(raw)
+      end
+
+      # Create or update customer bank account
+      #
+      # Create or update the bank account linked to this customer. This endpoint is available to biometrics session tokens so the kyc-app can collect disbursement bank data.
+      #
+      # @param id [String] Identificador único do cliente
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def upsert_bank_account(id, request_options: {}, **fields)
+        body = CustomerBankAccount.serialize_upsert_bank_account(**fields)
+        raw = @http.request(method: :post, path: "/customers/#{id}/bank-account", body:, request_options:)
+        CustomerBankAccount.deserialize(raw)
+      end
+
+      def credit_offers
+        @credit_offers ||= CreditOffers.new(@http)
+      end
+
+      def kyc_attachments
+        @kyc_attachments ||= KycAttachments.new(@http)
+      end
+
+      # Operations on the credit offers resource.
+      class CreditOffers
+        def initialize(http)
+          @http = http
+        end
+
+        # List credit offers for a customer
+        #
+        # List credit offers for a specific customer, filterable by `status`
+        #
+        # @param customer_id [String] Identificador único do cliente
+        # @param fields [Hash] Request body fields.
+        # @param request_options [Hash] Request options.
+        # @return [Object]
+        def list(customer_id, limit: Internal::OMIT, starting_after: Internal::OMIT, request_options: {}, **filters)
+          path = "/customers/#{customer_id}/credit-offers"
+          fetch_page = lambda do |cursor|
+            query = { limit:, starting_after: cursor || starting_after, **filters }
+                    .reject { |_key, value| Internal.omitted?(value) }
+            body = @http.request(method: :get, path:, query:, request_options:)
+            { data: body[:data].map { |raw| CreditOffer.deserialize(raw) }, has_more: body[:has_more] }
+          end
+          Dinie::Page.from_fetch(fetch_page)
+        end
+      end
+
+      # Operations on the kyc attachments resource.
+      class KycAttachments
+        def initialize(http)
+          @http = http
+        end
+
+        # Upload a KYC attachment
+        #
+        # Upload a KYC attachment for the customer via `multipart/form-data`. For document requirements, send a `file`. For data-type requirements (e.g. email), send a `value` instead.
+        #
+        # @param customer_id [String] Identificador único do cliente
+        # @param fields [Hash] Request body fields.
+        # @param request_options [Hash] Request options.
+        # @return [Object]
+        def create(customer_id, request_options: {}, **upload)
+          form = Dinie.serialize_kyc_upload(**upload)
+          body = Dinie::Internal::Multipart.new(fields: form.fields, file: form.file)
+          raw = @http.request(method: :post, path: "/customers/#{customer_id}/kyc-attachments", body:, request_options:)
+          KycAttachmentResponse.deserialize(raw)
+        end
+
+        # Upload a KYC selfie
+        #
+        # Session-only upload of a selfie for biometric validation. Counterpart of the polymorphic `/kyc-attachments` route, dedicated to selfies: `evidence_type` (`selfie`) and `attachment_type` (`photo`) are implicit, so the partner only supplies `requirement_id` (`selfie_{subject_id}`) and the `file`. Requires a session token bound to the customer — a partner bearer is denied (403), even with `kyc:upload`.
+        #
+        # @param customer_id [String] Identificador único do cliente
+        # @param fields [Hash] Request body fields.
+        # @param request_options [Hash] Request options.
+        # @return [Object]
+        def upload_selfie(customer_id, request_options: {}, **fields)
+          body = fields
+          raw = @http.request(method: :post, path: "/customers/#{customer_id}/kyc-attachments/selfie", body:,
+                              request_options:)
+          KycAttachmentResponse.deserialize(raw)
+        end
+      end
+    end
+  end
+end

data/lib/dinie/generated/resources/loans.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/paginator"
+require_relative "../types/loan"
+require_relative "../types/transaction"
+
+module Dinie
+  module Resources
+    # Operations on the loans resource.
+    class Loans
+      def initialize(http)
+        @http = http
+      end
+
+      # Create a loan
+      #
+      # Create a loan from a credit offer and accepted simulation; the CCB contract is generated synchronously and the loan starts in `awaiting_signatures` status
+      #
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def create(request_options: {}, **fields)
+        body = Loan.serialize_create(**fields)
+        raw = @http.request(method: :post, path: "/loans", body:, request_options:)
+        Loan.deserialize(raw)
+      end
+
+      # Retrieve a loan
+      #
+      # Return the full loan object with lifecycle details
+      #
+      # @param id [String] Identificador único do empréstimo
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def retrieve(id, request_options: {})
+        raw = @http.request(method: :get, path: "/loans/#{id}", request_options:)
+        Loan.deserialize(raw)
+      end
+
+      def transactions
+        @transactions ||= Transactions.new(@http)
+      end
+
+      # Operations on the transactions resource.
+      class Transactions
+        def initialize(http)
+          @http = http
+        end
+
+        # List loan transactions
+        #
+        # List installment transactions for a loan with due dates, amounts, and payment status
+        #
+        # @param loan_id [String] Identificador único do empréstimo
+        # @param request_options [Hash] Request options.
+        # @return [Object]
+        def list(loan_id, limit: Internal::OMIT, starting_after: Internal::OMIT, request_options: {})
+          path = "/loans/#{loan_id}/transactions"
+          fetch_page = lambda do |cursor|
+            query = { limit:, starting_after: cursor || starting_after }
+                    .reject { |_key, value| Internal.omitted?(value) }
+            body = @http.request(method: :get, path:, query:, request_options:)
+            { data: body[:data].map { |raw| Transaction.deserialize(raw) }, has_more: body[:has_more] }
+          end
+          Dinie::Page.from_fetch(fetch_page)
+        end
+      end
+    end
+  end
+end

data/lib/dinie/generated/resources/webhook_endpoints.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/paginator"
+require_relative "../types/webhook_endpoint"
+require_relative "../types/webhook_secret_rotation"
+
+module Dinie
+  module Resources
+    # Operations on the webhook endpoints resource.
+    class WebhookEndpoints
+      def initialize(http)
+        @http = http
+      end
+
+      # Create a webhook endpoint
+      #
+      # Create a webhook endpoint; the HMAC signing `secret` is returned only in this response
+      #
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def create(request_options: {}, **fields)
+        body = WebhookEndpoint.serialize_create(**fields)
+        raw = @http.request(method: :post, path: "/webhooks/endpoints", body:, request_options:)
+        WebhookEndpointWithSecret.deserialize(raw)
+      end
+
+      # Delete a webhook endpoint
+      #
+      # Delete a webhook endpoint and stop all deliveries
+      #
+      # @param id [String] Identificador único do endpoint de webhook
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def delete(id, request_options: {})
+        @http.request(method: :delete, path: "/webhooks/endpoints/#{id}", request_options:)
+        nil
+      end
+
+      # List webhook endpoints
+      #
+      # List all configured webhook endpoints with URL, subscribed events, and status
+      #
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def list(limit: Internal::OMIT, starting_after: Internal::OMIT, request_options: {})
+        fetch_page = lambda do |cursor|
+          query = { limit:, starting_after: cursor || starting_after }
+                  .reject { |_key, value| Internal.omitted?(value) }
+          body = @http.request(method: :get, path: "/webhooks/endpoints", query:, request_options:)
+          { data: body[:data].map { |raw| WebhookEndpoint.deserialize(raw) }, has_more: body[:has_more] }
+        end
+        Dinie::Page.from_fetch(fetch_page)
+      end
+
+      # Retrieve a webhook endpoint
+      #
+      # Return details of a specific webhook endpoint including URL, events, and status
+      #
+      # @param id [String] Identificador único do endpoint de webhook
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def retrieve(id, request_options: {})
+        raw = @http.request(method: :get, path: "/webhooks/endpoints/#{id}", request_options:)
+        WebhookEndpoint.deserialize(raw)
+      end
+
+      # Rotate the signing secret
+      #
+      # Rotate the HMAC signing secret; the previous secret remains valid for the grace period
+      #
+      # @param id [String] Identificador único do endpoint de webhook
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def rotate_secret(id, request_options: {}, **fields)
+        body = fields
+        raw = @http.request(method: :post, path: "/webhooks/endpoints/#{id}/rotate-secret", body:, request_options:)
+        WebhookSecretRotation.deserialize(raw)
+      end
+
+      # Update a webhook endpoint
+      #
+      # Update URL, events, description, or status of a webhook endpoint
+      #
+      # @param id [String] Identificador único do endpoint de webhook
+      # @param fields [Hash] Request body fields.
+      # @param request_options [Hash] Request options.
+      # @return [Object]
+      def update(id, request_options: {}, **fields)
+        body = WebhookEndpoint.serialize_update(**fields)
+        raw = @http.request(method: :patch, path: "/webhooks/endpoints/#{id}", body:, request_options:)
+        WebhookEndpoint.deserialize(raw)
+      end
+    end
+  end
+end

data/lib/dinie/generated/resources.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "resources/banks"
+require_relative "resources/biometrics"
+require_relative "resources/credentials"
+require_relative "resources/credit_offers"
+require_relative "resources/customers"
+require_relative "resources/loans"
+require_relative "resources/webhook_endpoints"

data/lib/dinie/generated/types/bank.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+
+module Dinie
+  class Bank < Internal::Model
+    attribute :display_name, :id, :name
+
+    def self.deserialize(raw)
+      new(
+        display_name: raw[:display_name],
+        id: raw[:id],
+        name: raw[:name]
+      )
+    end
+  end
+end

data/lib/dinie/generated/types/biometrics_session.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+
+module Dinie
+  class BiometricsSession < Internal::Model
+    attribute :expires_at, :session_url
+
+    def self.deserialize(raw)
+      new(
+        expires_at: raw[:expires_at],
+        session_url: raw[:session_url]
+      )
+    end
+  end
+end

data/lib/dinie/generated/types/biometrics_session_exchange_response.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+
+module Dinie
+  module BiometricsSessionExchangeResponseTokenType
+    BEARER = "bearer"
+    ALL = [BEARER].freeze
+  end
+
+  class BiometricsSessionExchangeResponse < Internal::Model
+    attribute :access_token, :customer_id, :expires_in, :token_type
+
+    def self.deserialize(raw)
+      new(
+        access_token: raw[:access_token],
+        customer_id: raw[:customer_id],
+        expires_in: raw[:expires_in],
+        token_type: raw[:token_type]
+      )
+    end
+  end
+end

data/lib/dinie/generated/types/credential.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+
+module Dinie
+  module CredentialStatus
+    ACTIVE = "active"
+    REVOKED = "revoked"
+    ALL = [ACTIVE, REVOKED].freeze
+  end
+
+  class Credential < Internal::Model
+    attribute :client_id, :created_at, :description, :expires_at, :id, :last_used_at, :name, :status, :updated_at
+
+    def self.deserialize(raw)
+      new(
+        client_id: raw[:client_id],
+        created_at: raw[:created_at],
+        description: raw[:description],
+        expires_at: raw[:expires_at],
+        id: raw[:id],
+        last_used_at: raw[:last_used_at],
+        name: raw[:name],
+        status: raw[:status],
+        updated_at: raw[:updated_at]
+      )
+    end
+
+    def self.serialize_create(name:, expires_at: Internal::OMIT)
+      { expires_at:, name: }.reject { |_key, value| Internal.omitted?(value) }
+    end
+  end
+
+  class CredentialWithSecret < Credential
+    attribute :client_secret
+
+    def self.deserialize(raw)
+      new(
+        client_id: raw[:client_id],
+        client_secret: raw[:client_secret],
+        created_at: raw[:created_at],
+        description: raw[:description],
+        expires_at: raw[:expires_at],
+        id: raw[:id],
+        last_used_at: raw[:last_used_at],
+        name: raw[:name],
+        status: raw[:status],
+        updated_at: raw[:updated_at]
+      )
+    end
+  end
+end

data/lib/dinie/generated/types/credit_offer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+
+module Dinie
+  class FixedInstallmentCreditOffer < Internal::Model
+    attribute :approved_amount, :created_at, :customer_id, :due_date_rule, :external_id, :id, :installments,
+              :min_amount, :monthly_interest_rate, :status, :updated_at, :valid_until
+
+    def self.deserialize(raw)
+      new(
+        approved_amount: raw[:approved_amount],
+        created_at: raw[:created_at],
+        customer_id: raw[:customer_id],
+        due_date_rule: raw[:due_date_rule],
+        external_id: raw[:external_id],
+        id: raw[:id],
+        installments: raw[:installments],
+        min_amount: raw[:min_amount],
+        monthly_interest_rate: raw[:monthly_interest_rate],
+        status: raw[:status],
+        updated_at: raw[:updated_at],
+        valid_until: raw[:valid_until]
+      )
+    end
+  end
+
+  class RangeInstallmentCreditOffer < Internal::Model
+    attribute :approved_amount, :created_at, :customer_id, :due_date_rule, :external_id, :id, :max_installments,
+              :min_amount, :min_installments, :monthly_interest_rate, :status, :updated_at, :valid_until
+
+    def self.deserialize(raw)
+      new(
+        approved_amount: raw[:approved_amount],
+        created_at: raw[:created_at],
+        customer_id: raw[:customer_id],
+        due_date_rule: raw[:due_date_rule],
+        external_id: raw[:external_id],
+        id: raw[:id],
+        max_installments: raw[:max_installments],
+        min_amount: raw[:min_amount],
+        min_installments: raw[:min_installments],
+        monthly_interest_rate: raw[:monthly_interest_rate],
+        status: raw[:status],
+        updated_at: raw[:updated_at],
+        valid_until: raw[:valid_until]
+      )
+    end
+  end
+
+  module CreditOffer
+    def self.deserialize(raw)
+      if raw.key?(:installments)
+        FixedInstallmentCreditOffer.deserialize(raw)
+      elsif raw.key?(:max_installments)
+        RangeInstallmentCreditOffer.deserialize(raw)
+      else
+        RangeInstallmentCreditOffer.deserialize(raw)
+      end
+    end
+  end
+end

data/lib/dinie/generated/types/customer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+require_relative "kyc"
+
+module Dinie
+  module CustomerStatus
+    CREATING = "creating"
+    PENDING_KYC = "pending_kyc"
+    UNDER_REVIEW = "under_review"
+    ACTIVE = "active"
+    DENIED = "denied"
+    ALL = [CREATING, PENDING_KYC, UNDER_REVIEW, ACTIVE, DENIED].freeze
+  end
+
+  class Customer < Internal::Model
+    attribute :cnpj, :cpf, :created_at, :email, :external_id, :id, :kyc, :metadata, :name, :phone, :status,
+              :trading_name, :updated_at
+
+    def self.deserialize(raw)
+      new(
+        cnpj: raw[:cnpj],
+        cpf: raw[:cpf],
+        created_at: raw[:created_at],
+        email: raw[:email],
+        external_id: raw[:external_id],
+        id: raw[:id],
+        kyc: raw[:kyc]&.map { |requirement| Dinie.deserialize_kyc_requirement(requirement) },
+        metadata: raw[:metadata],
+        name: raw[:name],
+        phone: raw[:phone],
+        status: raw[:status],
+        trading_name: raw[:trading_name],
+        updated_at: raw[:updated_at]
+      )
+    end
+
+    def self.serialize_create(cnpj:, cpf:, email:, phone:, external_id: Internal::OMIT, name: Internal::OMIT)
+      { cnpj:, cpf:, email:, external_id:, name:, phone: }.reject { |_key, value| Internal.omitted?(value) }
+    end
+
+    def self.serialize_update(email: Internal::OMIT, phone: Internal::OMIT)
+      { email:, phone: }.reject { |_key, value| Internal.omitted?(value) }
+    end
+  end
+end

data/lib/dinie/generated/types/customer_bank_account.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+
+module Dinie
+  module CustomerBankAccountKind
+    CHECKING = "checking"
+    SAVING = "saving"
+    PAYMENT = "payment"
+    ALL = [CHECKING, SAVING, PAYMENT].freeze
+  end
+
+  class CustomerBankAccount < Internal::Model
+    attribute :bank_id, :bank_name, :branch, :digit, :id, :kind, :number, :updated_at
+
+    def self.deserialize(raw)
+      new(
+        bank_id: raw[:bank_id],
+        bank_name: raw[:bank_name],
+        branch: raw[:branch],
+        digit: raw[:digit],
+        id: raw[:id],
+        kind: raw[:kind],
+        number: raw[:number],
+        updated_at: raw[:updated_at]
+      )
+    end
+
+    def self.serialize_upsert_bank_account(bank_id:, branch:, digit:, kind:, number:)
+      { bank_account: { bank_id:, branch:, digit:, kind:, number: } }
+    end
+  end
+end

data/lib/dinie/generated/types/ids.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Dinie
+  module Internal
+    ID_PATTERNS = {
+      api_client: /\Adinie_ci_(live|test)_[A-Za-z0-9]+\z/,
+      bank_account: /\Aba_[0-9a-f]{32}\z/,
+      credit_offer: /\Aco_[0-9a-f]{32}\z/,
+      customer: /\Acust_[0-9a-f]{32}\z/,
+      event: /\Aevt_[0-9a-f]{32}\z/,
+      loan: /\Aln_[0-9a-f]{32}\z/,
+      simulation: /\Asim_[0-9a-f]{32}\z/,
+      transaction: /\Atx_[0-9a-f]{32}\z/,
+      webhook_delivery: /\Adlv_[0-9a-f]{32}\z/,
+      webhook_endpoint: /\Awe_[0-9a-f]{32}\z/
+    }.freeze
+  end
+end