dinie-sdk-sandbox 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2a373cf8978cc140407d0d105f1c2028474ed59774e29b425c8f32428f8a4beb
+  data.tar.gz: ae691f9d8933e27c5a9c197564226372d6169c571d4460477ffd689a1160dab2
+SHA512:
+  metadata.gz: 81da4d452ff69a12f68f0054d5d681018c47871a3a35427fdc9d2d4ef50fb6c16e97ba93a38e053486671748c116cce0d3e3bd79dc57e135c940aa4c28c2d98e
+  data.tar.gz: f75696efcbb3c2d616ee42d4be9d863ad317c4e2acfe1b415c702a79f6fc14946ffdd97b930a22cefa9ccbaa0165e12b785e948f63b2cf6949011a1002502bd4

data/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+All notable changes to the `dinie` gem are documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [1.1.0] - 2026-06-09
+
+## [1.0.0] — 2026-06-08
+
+### Added
+
+- **Publishable gem** (`dinie-sdk-sandbox` on RubyGems.org): `allowed_push_host` wired;
+  `api_version` gemspec metadata (`2026-03-01`); `rubygems_mfa_required` satisfied by OIDC
+  Trusted Publishing.
+- **`Dinie::VERSION = "1.0.0"`** — first stable public release.
+- **api_version constant** (`lib/dinie/generated/api_version.rb`): `Dinie::Generated::API_VERSION`
+  sourced from `openapi.info.version`; User-Agent now reads it (no more `2026-05-10` literal).
+- **YARD documentation** on every public method and class in `lib/dinie/generated/` (0 undocumented
+  methods — was 128/206 undocumented).
+- **CI/CD workflows**: `publish.yml` (OIDC RubyGems via `rubygems/release-gem@v1`, keyless,
+  no `RUBYGEMS_API_KEY`); `tag-release.yml` (GitHub App token auto-tag on `generator-bump` PR merge).
+- **Drift gate** in CI: hermetic `sdk-generator check --target ruby` — edit ⇒ red, revert ⇒ green.
+
+### Added
+
+- Project scaffold: `dinie.gemspec` (private gem, Ruby >= 3.1; `faraday ~> 2.0` +
+  `net-http-persistent ~> 4.0`), `Gemfile`, `Rakefile`.
+- `lib/dinie.rb` deterministic barrel (explicit `require_relative`, no Zeitwerk) and
+  `lib/dinie/version.rb` (`Dinie::VERSION`).
+- `lib/dinie/runtime/` <-> `lib/dinie/generated/` directory boundary with `CODEOWNERS`
+  (human-owned runtime, bot-owned generated layer — architecture §4.2).
+- RSpec + WebMock (zero network) test tree with a `Dinie::VERSION` smoke spec.
+- RuboCop config, RBS `sig/` skeleton + `Steepfile`, YARD `.yardopts`.
+- CI workflow: `bundle install` -> RuboCop -> RSpec -> Steep (informative) on Ruby
+  3.1, 3.2, 3.3.
+- `.env.example` for the deferred (non-gate) live smoke E2E.

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dinie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,280 @@
+# dinie
+
+Official Ruby SDK for the [Dinie](https://dinie.com.br) V3 API (backend-only).
+
+A hand-written, synchronous Ruby client for the Dinie credit-as-a-service platform: OAuth2
+client-credentials auth (handled for you), automatic retries with idempotency, cursor pagination,
+typed errors, and webhook verification. Snake_case throughout — the wire and the Ruby surface match,
+so there is no casing to translate.
+
+> **Status — `1.0.0`, published to RubyGems.** The public surface is frozen against the Dinie V3
+> contract (api-version `2026-03-01`).
+
+## Requirements
+
+- Ruby >= 3.1
+- A Dinie API credential (`client_id` + `client_secret`)
+
+## Installation
+
+```ruby
+# Gemfile
+gem "dinie-sdk-sandbox"
+```
+
+```bash
+bundle install
+```
+
+The SDK depends on `faraday` (with the `net-http-persistent` adapter for a real connection pool)
+and `faraday-multipart`. Both are pulled in automatically.
+
+## Quickstart
+
+```ruby
+require "dinie"
+
+client = Dinie::Client.new(client_id: "dinie_ci_…", client_secret: "…")
+
+customer = client.customers.create(
+  email: "ana@example.com",
+  phone: "+5511999999999",
+  cpf: "123.456.789-09",
+  cnpj: "12.345.678/0001-95"
+)
+
+customer.id      # => "cust_…"
+customer.status  # => "pending_kyc"
+```
+
+The client owns a connection pool and an in-memory OAuth2 token cache, so **construct it once and
+reuse it**. Tokens are fetched and refreshed transparently — you never call the token endpoint
+yourself.
+
+### Configuration
+
+Pass options to the constructor, or let the SDK read them from the environment.
+
+```ruby
+client = Dinie::Client.new(
+  client_id:     "dinie_ci_…",   # or ENV["DINIE_CLIENT_ID"]
+  client_secret: "…",            # or ENV["DINIE_CLIENT_SECRET"]
+  base_url:      nil,            # or ENV["DINIE_BASE_URL"]; default https://api.dinie.com.br/api/v3
+  timeout:       30,            # per-request timeout, in SECONDS
+  max_retries:   3,            # retries after the first attempt
+  idempotency:   true,        # auto X-Idempotency-Key on POST/PATCH
+  log_level:     :off         # :off | :error | :warn | :info | :debug (or ENV["DINIE_LOG"])
+)
+```
+
+| Variable             | Used for                                                       |
+| -------------------- | -------------------------------------------------------------- |
+| `DINIE_CLIENT_ID`    | OAuth2 client id (when `client_id:` is omitted)                |
+| `DINIE_CLIENT_SECRET`| OAuth2 client secret (when `client_secret:` is omitted)        |
+| `DINIE_BASE_URL`     | API base URL incl. `/api/v3` (when `base_url:` is omitted)     |
+| `DINIE_LOG`          | log level (when `log_level:` is omitted)                       |
+
+Need a one-off override (a tighter timeout for a single call path)? Clone the client — the clone
+**shares the same token cache and connection pool**, so it never triggers a re-auth:
+
+```ruby
+fast = client.with_options(timeout: 5)
+```
+
+Logging is opt-in and redacts credentials and PII (`authorization`, `cpf`, `cnpj`, `client_secret`,
+`phone`, …) before anything is written.
+
+## End-to-end flow: Customer → Credit Offer → Loan
+
+The credit lifecycle is: register a customer, let Dinie run KYC and underwriting (you are notified by
+webhook — see below), then read the resulting **credit offer**, **simulate** it, and **contract** a
+loan from the accepted simulation.
+
+```ruby
+client = Dinie::Client.new(client_id: "dinie_ci_test", client_secret: "dinie_secret_test")
+
+# 1. Register the customer.
+customer = client.customers.create(
+  email: "ana@example.com",
+  phone: "+5511999999999",
+  cpf:   "123.456.789-09",
+  cnpj:  "12.345.678/0001-95"
+)
+
+# 2. Dinie runs KYC + underwriting. When the customer is approved, a `credit_offer.available`
+#    webhook fires. Read the offers (they are NOT created by you):
+offer = client.customers.credit_offers.list(customer.id).first
+# …or fetch a known offer directly:
+offer = client.credit_offers.retrieve("co_0550e8400e29b41d4a716446655440000")
+
+offer.approved_amount        # => 25000.0  (Money — a Float, BRL)
+offer.monthly_interest_rate  # => 4.5
+
+# 3. Simulate the offer for the amount and term the customer wants.
+simulation = client.credit_offers.create_simulation(
+  offer.id,
+  requested_amount:  25_000.0,
+  installment_count: 12
+)
+
+simulation.installment_amount  # => 2_343.21
+simulation.total_amount        # => 28_118.52
+
+# 4. Contract the loan from the accepted simulation.
+loan = client.loans.create(
+  credit_offer_id:    offer.id,
+  simulation_id:      simulation.id,
+  installment_count:  simulation.installment_count,
+  installment_amount: simulation.installment_amount,
+  first_due_date:     "2026-07-10"  # ISO-8601 date
+)
+
+loan.id          # => "ln_…"
+loan.status      # => "awaiting_signatures"
+loan.signing_url # => CCB signature URL (present while awaiting signatures)
+
+# Later, inspect the amortization schedule:
+client.loans.transactions.list(loan.id).each do |installment|
+  puts "#{installment.due_date}: #{installment.amount_due} (#{installment.status})"
+end
+```
+
+> **Note.** All monetary fields are `Money` — a plain `Float` in BRL. All timestamps
+> (`created_at`, `valid_until`, …) are integer Unix epoch seconds; only `RateLimit#reset_at` is a
+> `Time`. ID prefixes (`cust_`, `co_`, `sim_`, `ln_`, `tx_`) are documented on each field; the value
+> itself is a `String`.
+
+## Pagination
+
+List endpoints return a `Dinie::Page` that auto-paginates by cursor. It does **not** load every page
+eagerly — `#each` walks pages on demand, following `has_more` (never the page size).
+
+```ruby
+# Iterate every customer across all pages:
+client.customers.list(limit: 50).each do |customer|
+  puts customer.id
+end
+
+# Page-by-page, for manual control:
+client.customers.list.each_page do |page|
+  process(page.data)        # Array<Dinie::Customer>
+  page.has_more             # => true / false
+end
+
+# Just the first N, fetched lazily (only as many pages as needed):
+top = client.customers.list.first(10)
+```
+
+Without a block, `#each` and `#each_page` return an `Enumerator`, so `.map` / `.lazy` work too.
+
+`client.banks.list` is the one exception: the bank directory is **not** paginated, so it returns a
+flat `Array<Dinie::Bank>` in a single call.
+
+## Webhooks
+
+Dinie delivers events (Standard Webhooks v1, HMAC-SHA256). `Dinie::Webhooks.extract` verifies the
+signature **and** the timestamp, then returns the typed event — or raises. It never returns an
+unverified payload, and it needs no client (verification is just your signing secret).
+
+```ruby
+# In your Rack / Rails / Sinatra handler:
+event = Dinie::Webhooks.extract(
+  headers: request.headers.to_h,   # must include webhook-id / webhook-timestamp / webhook-signature
+  body:    request.raw_post,       # the RAW body, before JSON parsing
+  secret:  ENV["DINIE_WEBHOOK_SECRET"]  # "whsec_…" (or an Array of secrets during rotation)
+)
+
+case event
+when Dinie::Events::CustomerActive
+  activate_customer(event.data.id)
+when Dinie::Events::CreditOfferAvailable
+  notify_offer(event.data.customer_id, event.data.approved_amount)
+when Dinie::Events::LoanActive
+  release_funds(event.data.id)
+when Dinie::Events::LoanPaymentReceived
+  record_payment(event.data.id, event.data.payment.amount)
+else
+  Rails.logger.info("Unhandled Dinie event: #{event.type}")
+end
+```
+
+Header lookup is case-insensitive and accepts string or symbol keys. The signed payload is
+`"{webhook-id}.{webhook-timestamp}.{body}"`, the comparison is constant-time, and multiple
+space-separated `v1,<sig>` signatures are accepted (so secret rotation works from either side).
+
+Failures raise, so you can map them to HTTP responses:
+
+| Raised                                | When                                                            |
+| ------------------------------------- | --------------------------------------------------------------- |
+| `Dinie::WebhookSignatureError`        | a header is missing, no secret matched, or the HMAC differs      |
+| `Dinie::WebhookTimestampError`        | the timestamp is malformed or outside the ±300s window           |
+| `Dinie::UnknownWebhookEventError`     | the signature is valid but the `type` is not in the SDK's catalog |
+
+## Error handling
+
+Every non-2xx response becomes a typed error. The hierarchy lets you rescue broadly or narrowly, and
+each error carries the machine-readable `code` and the `request_id` for support tickets.
+
+```ruby
+begin
+  client.credit_offers.retrieve("co_does_not_exist")
+rescue Dinie::NotFoundError => e
+  warn "Not found (#{e.code}) — request #{e.request_id}"
+rescue Dinie::ValidationError => e
+  warn "Invalid: #{e.detail}"          # RFC 9457 Problem Details
+rescue Dinie::RateLimitError
+  # transient — the SDK already retried with backoff; back off further if you see this
+rescue Dinie::APIStatusError => e
+  warn "API error #{e.status}: #{e.title}"
+rescue Dinie::APIConnectionError
+  # network/DNS/timeout — no response was received
+end
+```
+
+```text
+Dinie::Error
+├── Dinie::APIError
+│   ├── Dinie::APIConnectionError → Dinie::APITimeoutError
+│   └── Dinie::APIStatusError
+│       ├── Dinie::BadRequestError   (400)   Dinie::ConflictError    (409)
+│       ├── Dinie::AuthError         (401)   Dinie::ValidationError  (422)
+│       ├── Dinie::PermissionError   (403)   Dinie::RateLimitError   (429)
+│       └── Dinie::NotFoundError     (404)   Dinie::ServerError      (500 + ≥500 fallback)
+├── Dinie::OAuthError                        # token handshake failed
+├── Dinie::WebhookSignatureError
+├── Dinie::WebhookTimestampError
+└── Dinie::UnknownWebhookEventError
+```
+
+Retries are automatic for `408/429/500/502/503/504` and transport errors (exponential backoff with
+jitter, honoring `Retry-After` up to 60s). `409`/`410` are never retried. A stable
+`X-Idempotency-Key` is minted once per logical write and reused across retries, so a retry never
+creates a duplicate resource.
+
+After any call you can read the latest rate-limit snapshot:
+
+```ruby
+rl = client.rate_limit            # => Dinie::RateLimit or nil
+rl&.remaining                     # => 87
+rl&.reset_at                      # => 2026-06-02 12:00:30 UTC (a Time)
+```
+
+## Types
+
+The full public surface is mirrored as RBS signatures under [`sig/`](sig/) — install the gem and
+point [Steep](https://github.com/soutaro/steep) or Solargraph at it for static type checking and
+editor hover. YARD documentation covers every public class and method.
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec        # tests — WebMock, zero network
+bundle exec rubocop      # lint
+bundle exec steep check  # type check (informative in v1 — see Steepfile)
+bundle exec yard doc     # build the API docs
+```
+
+## License
+
+[MIT](LICENSE) © Dinie

data/lib/dinie/generated/api_version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# generated — do not edit
+module Dinie
+  module Generated
+    API_VERSION = "2026-03-01"
+  end
+end

data/lib/dinie/generated/client.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "faraday/net_http_persistent"
+
+module Dinie
+  class Client
+    DEFAULT_TIMEOUT_SECONDS = Internal::HttpClient::DEFAULT_TIMEOUT_SECONDS
+    DEFAULT_MAX_RETRIES = Internal::HttpClient::DEFAULT_MAX_RETRIES
+
+    def initialize(client_id: nil, client_secret: nil, code: nil, base_url: nil, timeout: DEFAULT_TIMEOUT_SECONDS,
+                   max_retries: DEFAULT_MAX_RETRIES, idempotency: true, log_level: :off, logger: nil,
+                   adapter: nil, token_manager: nil, connection: nil)
+      @base_url = first_present(base_url, ENV.fetch("DINIE_BASE_URL", nil)) || Internal::HttpClient::DEFAULT_BASE_URL
+      @options = {
+        timeout: timeout, max_retries: max_retries, idempotency: idempotency,
+        log_level: log_level, logger: logger, adapter: adapter
+      }
+
+      @connection = connection || build_connection(log_level: log_level, logger: logger, adapter: adapter)
+      @token_manager = token_manager || build_token_manager(client_id, client_secret, code)
+      @http = Internal::HttpClient.new(
+        token_manager: @token_manager, base_url: @base_url, timeout: timeout,
+        max_retries: max_retries, idempotency: idempotency, connection: @connection
+      )
+    end
+
+    def banks
+      @banks ||= Resources::Banks.new(@http)
+    end
+
+    def biometrics
+      @biometrics ||= Resources::Biometrics.new(@http)
+    end
+
+    def credentials
+      @credentials ||= Resources::Credentials.new(@http)
+    end
+
+    def credit_offers
+      @credit_offers ||= Resources::CreditOffers.new(@http)
+    end
+
+    def customers
+      @customers ||= Resources::Customers.new(@http)
+    end
+
+    def loans
+      @loans ||= Resources::Loans.new(@http)
+    end
+
+    def webhook_endpoints
+      @webhook_endpoints ||= Resources::WebhookEndpoints.new(@http)
+    end
+
+    def rate_limit
+      @http.rate_limit
+    end
+
+    def with_options(**overrides)
+      self.class.new(
+        base_url: @base_url, token_manager: @token_manager, connection: @connection,
+        **@options.merge(overrides)
+      )
+    end
+
+    private
+
+    def build_token_manager(client_id, client_secret, code = nil)
+      resolved_id = first_present(client_id, ENV.fetch("DINIE_CLIENT_ID", nil))
+      resolved_secret = first_present(client_secret, ENV.fetch("DINIE_CLIENT_SECRET", nil))
+      raise Dinie::Error, "Missing Dinie client id: pass `client_id:` or set DINIE_CLIENT_ID." if resolved_id.nil?
+      if resolved_secret.nil?
+        raise Dinie::Error, "Missing Dinie client secret: pass `client_secret:` or set DINIE_CLIENT_SECRET."
+      end
+
+      Internal::TokenManager.new(
+        client_id: resolved_id, client_secret: resolved_secret,
+        base_url: @base_url, connection: @connection, code: code
+      )
+    end
+
+    def build_connection(log_level:, logger:, adapter:)
+      Faraday.new(url: @base_url) do |faraday|
+        faraday.request :multipart
+        faraday.use Internal::Middleware::Logging, level: log_level, logger: logger
+        faraday.adapter(adapter || :net_http_persistent)
+      end
+    end
+
+    def first_present(*candidates)
+      candidates.find { |value| !value.nil? && value != "" }
+    end
+  end
+end

data/lib/dinie/generated/errors/registry.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/errors"
+
+module Dinie
+  class AuthError < APIStatusError; end
+  class BadRequestError < APIStatusError; end
+  class ConflictError < APIStatusError; end
+  class NotFoundError < APIStatusError; end
+  class PermissionDeniedError < APIStatusError; end
+  class RateLimitError < APIStatusError; end
+  class ServerError < APIStatusError; end
+  class ValidationError < APIStatusError; end
+
+  module Internal
+    ERROR_REGISTRY = {
+      by_type: {
+        "https://docs.dinie.com/errors/invalid-request" => Dinie::BadRequestError,
+        "https://docs.dinie.com/errors/authentication-failed" => Dinie::AuthError,
+        "https://docs.dinie.com/errors/forbidden" => Dinie::PermissionDeniedError,
+        "https://docs.dinie.com/errors/not-found" => Dinie::NotFoundError,
+        "https://docs.dinie.com/errors/conflict" => Dinie::ConflictError,
+        "https://docs.dinie.com/errors/validation-failed" => Dinie::ValidationError,
+        "https://docs.dinie.com/errors/rate-limit-exceeded" => Dinie::RateLimitError,
+        "https://docs.dinie.com/errors/internal" => Dinie::ServerError
+      }.freeze,
+      by_status: {
+        400 => Dinie::BadRequestError,
+        401 => Dinie::AuthError,
+        403 => Dinie::PermissionDeniedError,
+        404 => Dinie::NotFoundError,
+        409 => Dinie::ConflictError,
+        422 => Dinie::ValidationError,
+        429 => Dinie::RateLimitError,
+        500 => Dinie::ServerError
+      }.freeze,
+      fallback_5xx: Dinie::ServerError
+    }.freeze
+  end
+end

data/lib/dinie/generated/events/base.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+
+module Dinie
+  module Events
+    class WebhookEventBase < Internal::Model
+      attribute :api_version, :created_at, :data, :delivery_id, :id, :timestamp, :type
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+require_relative "base"
+
+module Dinie
+  module Events
+    class CreditOfferData < Internal::Model
+      attribute :approved_amount, :customer_id, :due_date_rule, :external_id, :id, :installments, :min_amount,
+                :monthly_interest_rate, :status, :valid_until
+
+      def self.deserialize(raw)
+        new(
+          approved_amount: raw[:approved_amount],
+          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],
+          valid_until: raw[:valid_until]
+        )
+      end
+    end
+
+    class CreditOfferAvailable < WebhookEventBase
+      def self.deserialize(raw)
+        new(
+          api_version: raw[:api_version],
+          created_at: raw[:created_at],
+          data: CreditOfferData.deserialize(raw[:data]),
+          delivery_id: raw[:delivery_id],
+          id: raw[:id],
+          timestamp: raw[:timestamp],
+          type: "credit_offer.available"
+        )
+      end
+    end
+
+    class CreditOfferExpired < WebhookEventBase
+      def self.deserialize(raw)
+        new(
+          api_version: raw[:api_version],
+          created_at: raw[:created_at],
+          data: CreditOfferData.deserialize(raw[:data]),
+          delivery_id: raw[:delivery_id],
+          id: raw[:id],
+          timestamp: raw[:timestamp],
+          type: "credit_offer.expired"
+        )
+      end
+    end
+  end
+end

data/lib/dinie/generated/events/customer_created.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+require_relative "../types/kyc"
+require_relative "base"
+
+module Dinie
+  module Events
+    class CustomerCreatedData < Internal::Model
+      attribute :cnpj, :cpf, :email, :external_id, :id, :kyc, :name, :phone, :status, :trading_name
+
+      def self.deserialize(raw)
+        new(
+          cnpj: raw[:cnpj],
+          cpf: raw[:cpf],
+          email: raw[:email],
+          external_id: raw[:external_id],
+          id: raw[:id],
+          kyc: raw[:kyc].map { |requirement| Dinie.deserialize_kyc_requirement(requirement) },
+          name: raw[:name],
+          phone: raw[:phone],
+          status: raw[:status],
+          trading_name: raw[:trading_name]
+        )
+      end
+    end
+
+    class CustomerCreated < WebhookEventBase
+      def self.deserialize(raw)
+        new(
+          api_version: raw[:api_version],
+          created_at: raw[:created_at],
+          data: CustomerCreatedData.deserialize(raw[:data]),
+          delivery_id: raw[:delivery_id],
+          id: raw[:id],
+          timestamp: raw[:timestamp],
+          type: "customer.created"
+        )
+      end
+    end
+  end
+end

data/lib/dinie/generated/events/customer_denied.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+require_relative "base"
+
+module Dinie
+  module Events
+    class CustomerDeniedData < Internal::Model
+      attribute :cnpj, :cpf, :email, :external_id, :id, :name, :phone, :status
+
+      def self.deserialize(raw)
+        new(
+          cnpj: raw[:cnpj],
+          cpf: raw[:cpf],
+          email: raw[:email],
+          external_id: raw[:external_id],
+          id: raw[:id],
+          name: raw[:name],
+          phone: raw[:phone],
+          status: raw[:status]
+        )
+      end
+    end
+
+    class CustomerDenied < WebhookEventBase
+      def self.deserialize(raw)
+        new(
+          api_version: raw[:api_version],
+          created_at: raw[:created_at],
+          data: CustomerDeniedData.deserialize(raw[:data]),
+          delivery_id: raw[:delivery_id],
+          id: raw[:id],
+          timestamp: raw[:timestamp],
+          type: "customer.denied"
+        )
+      end
+    end
+  end
+end

data/lib/dinie/generated/events/customer_kyc_updated.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../../runtime/model"
+require_relative "../types/kyc"
+require_relative "base"
+
+module Dinie
+  module Events
+    class CustomerKycUpdatedData < Internal::Model
+      attribute :external_id, :id, :kyc, :status
+
+      def self.deserialize(raw)
+        new(
+          external_id: raw[:external_id],
+          id: raw[:id],
+          kyc: raw[:kyc].map { |requirement| Dinie.deserialize_kyc_requirement(requirement) },
+          status: raw[:status]
+        )
+      end
+    end
+
+    class CustomerKycUpdated < WebhookEventBase
+      def self.deserialize(raw)
+        new(
+          api_version: raw[:api_version],
+          created_at: raw[:created_at],
+          data: CustomerKycUpdatedData.deserialize(raw[:data]),
+          delivery_id: raw[:delivery_id],
+          id: raw[:id],
+          timestamp: raw[:timestamp],
+          type: "customer.kyc_updated"
+        )
+      end
+    end
+  end
+end