conexa 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '050626980d9f896ca2c70ed30a27c1cfda7d0d30c89e25c90e86422d122fb1af'
-  data.tar.gz: 43134221ca4dd8f38bc3f8a62bfffe2807d1565e949e2adf72d446fa14db01cf
+  metadata.gz: 76a95e870fc63f79b15b5227f1f0a10d94471efe573662dc626e42e57cf77b82
+  data.tar.gz: 92fce7222c5b9adad92e6524e6dbfb3466bc1282a81768c5872922af37d2085b
 SHA512:
-  metadata.gz: 298ef626afb7783dff6d66161e20ff4b28b30b0d81761ce3f5debf187f1d60e0d01814004d3372ad6531b5e40e22e110af471522bbc577e3c0baac63dfb17014
-  data.tar.gz: 768fbc470c103074ff5b768bf78ba6ed47385c4d06a7cadba7aed395947da92c73756c8f72c06e66be15520974c7f0c2e8438dfc567181cc83357416cad251d5
+  metadata.gz: 4071bc748f2855c39eb48e7360bf4d519f0502d898ca7e915c88c41115bb85422766a2e0274d9ab39ac032de69507dd2275b5fa976de26b8dc586846f3089814
+  data.tar.gz: 2962227ceb63eb324be8289502669995d4ac4d1136fd18570f972024b0774e0ff874c5c71d7fca8c296cd882850284415d8ce784312d1867d7471b3783ec79d3

data/CHANGELOG.md

@@ -7,6 +7,67 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.0] - 2026-03-31
+
+### Added
+- `Result#next_page` — automatically fetches the next page preserving original filter params
+- `Result#has_next?` — convenience method to check if more pages are available
+- Pagination migration guide added to README (EN/PT-BR) and REFERENCE.md
+- Validation for `limit` (must be positive integer) and `offset` (must be non-negative integer) parameters
+- `frozen_string_literal: true` pragma added to all Ruby source files
+- ActiveSupport compatibility guard for `blank?`/`present?` monkey-patches
+- `respond_to_missing?` implemented in `ConexaObject` and `Result` (Ruby best practice)
+- Integration tests for all new API v2 resources (24 specs)
+- Unit tests for pagination validation and `class_name` camelCase preservation (6 specs)
+- Total: 502 specs
+
+### Changed
+- **Breaking**: Default pagination is now `limit: 100, offset: 0` (was `page: 1, size: 100`)
+  - Calling `.all` or `.find_by` without pagination params now uses the new model
+  - Legacy `page`/`size` is only used when explicitly passed (emits deprecation warning)
+- `Model.all` simplified — delegates directly to `find_by` without double param extraction
+- `Model.class_name` now returns proper lowerCamelCase (e.g. `recurringSale` instead of `recurringsale`)
+- `OrderCommom` renamed to `OrderCommon` (backwards-compatible alias kept)
+- `Bill#save` now raises `NoMethodError` with descriptive message
+- README updated: all examples now use correct method names (`.all`, `.find`, `.destroy`)
+- README error handling section rewritten with actual exception classes
+
+### Fixed
+- **Concurrency bug**: `DEFAULT_HEADERS` constant was mutated on every request; now uses `.dup`
+- **Boolean false bug**: `Result#method_missing` skipped `false` attribute values due to `||` operator
+- **ValidationError crash**: undefined variable `error` in block scope — fixed to use `msg`
+- **TokenManager typo**: `ShiConexa` → `Conexa` in credentials handling
+- **Singularize**: `SINGULARS` patterns were stored as strings, never used as regex — rewritten with proper `Regexp` objects
+- **Deep copy**: `Result#next_page` now uses `Marshal.load(Marshal.dump(...))` to prevent param mutation between pages
+- Stray `-` character removed from `util.rb`
+- Removed dead code: `Hash#except_nested` monkey-patch, commented-out `to_s` method
+
+## [0.0.9] - 2026-03-30
+
+### Added
+- **New pagination model**: `limit`/`offset`/`hasNext` — more efficient, avoids calculating total records
+  - Pass `limit:` to any `.all` or `.find_by` to use the new pagination
+  - Old `page`/`size` pagination emits deprecation warning (deadline: 2026-08-01)
+- **New resources:**
+  - `Conexa::ReceivingMethod` — Meios de Recebimento (`/receivingMethods`, `/receivingMethod/:id`)
+  - `Conexa::PaymentMethod` — Meios de Pagamento (`/paymentMethods`, `/paymentMethod/:id`)
+  - `Conexa::BillCategory` — Categorias de Despesa (`/billCategories`, `/billCategory/:id`)
+  - `Conexa::BillSubcategory` — Subcategorias de Despesa (`/billSubcategories`, `/billSubcategory/:id`)
+  - `Conexa::CostCenter` — Centros de Custo (`/costCenters`, `/costCenter/:id`)
+  - `Conexa::Account` — Contas Bancárias (`/accounts`, `/account/:id`)
+  - `Conexa::ServiceCategory` — Categorias de Serviço (`/serviceCategories`, `/serviceCategory/:id`)
+  - `Conexa::RoomBooking` — Reservas de Sala (`/room/bookings`, `/room/booking`) with cancel, checkout, checkin
+- `Product` now supports full CRUD (POST `/product`, DELETE `/product/:id`) per API v2 update
+
+### Changed
+- `Model#extract_page_size_or_params` rewritten to support dual pagination modes
+- `Customer.persons`, `Customer.contracts`, `Customer.charges` migrated to `limit: 100`
+
+### Fixed
+- `Supplier` list URL corrected from `/supplier` to `/suppliers`
+- `Supplier` now has `primary_key_attribute :supplier_id`
+- `Product` now has `primary_key_attribute :product_id`
+
 ## [0.0.8] - 2026-02-19
 
 ### Fixed
@@ -61,7 +122,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Charge with settle and PIX methods
 - Pagination support
 
-[Unreleased]: https://github.com/guilhermegazzinelli/conexa-ruby/compare/v0.0.8...HEAD
+[Unreleased]: https://github.com/guilhermegazzinelli/conexa-ruby/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/guilhermegazzinelli/conexa-ruby/compare/v0.0.9...v0.1.0
+[0.0.9]: https://github.com/guilhermegazzinelli/conexa-ruby/compare/v0.0.8...v0.0.9
 [0.0.8]: https://github.com/guilhermegazzinelli/conexa-ruby/compare/v0.0.7...v0.0.8
 [0.0.7]: https://github.com/guilhermegazzinelli/conexa-ruby/compare/v0.0.6...v0.0.7
 [0.0.6]: https://github.com/guilhermegazzinelli/conexa-ruby/compare/v0.0.5...v0.0.6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    conexa (0.0.8)
+    conexa (0.1.0)
       jwt
       multi_json
       rest-client

data/README.md

@@ -46,13 +46,13 @@ Conexa.configure do |config|
 end
 
 # List customers
-customers = Conexa::Customer.list
+customers = Conexa::Customer.all
 customers.data.each do |customer|
   puts "#{customer.customer_id}: #{customer.name}"
 end
 
 # Get a specific customer
-customer = Conexa::Customer.retrieve(127)
+customer = Conexa::Customer.find(127)
 puts customer.name
 puts customer.address.city
 ```
@@ -110,7 +110,7 @@ customer = Conexa::Customer.create(
 )
 
 # Retrieve customer
-customer = Conexa::Customer.retrieve(127)
+customer = Conexa::Customer.find(127)
 customer.name           # => "Empresa ABC Ltda"
 customer.company_id     # => 3
 customer.is_active      # => true
@@ -118,14 +118,16 @@ customer.address.city   # => "Campinas"
 customer.legal_person['cnpj']  # => "99.557.155/0001-90"
 
 # Update customer
-Conexa::Customer.update(127, name: 'New Name', cell_number: '11888887777')
+customer = Conexa::Customer.find(127)
+customer.name = 'New Name'
+customer.cell_number = '11888887777'
+customer.save
 
-# List customers with filters
-customers = Conexa::Customer.list(
+# List customers with filters (new pagination)
+customers = Conexa::Customer.all(
   company_id: [3],
   is_active: true,
-  page: 1,
-  size: 20
+  limit: 20
 )
 ```
 
@@ -153,7 +155,7 @@ contract = Conexa::Contract.create_with_products(
 )
 
 # Retrieve contract
-contract = Conexa::Contract.retrieve(456)
+contract = Conexa::Contract.find(456)
 
 # Cancel contract
 Conexa::Contract.cancel(456, cancel_date: '2024-12-31')
@@ -175,13 +177,13 @@ sale = Conexa::Sale.create(
 puts sale.id  # => 188481
 
 # Retrieve sale
-sale = Conexa::Sale.retrieve(188510)
+sale = Conexa::Sale.find(188510)
 sale.status         # => "notBilled"
 sale.amount         # => 80.99
 sale.discount_value # => 69.21
 
 # List sales
-sales = Conexa::Sale.list(
+sales = Conexa::Sale.all(
   customer_id: [450, 216],
   status: 'notBilled',
   date_from: '2024-01-01',
@@ -191,10 +193,13 @@ sales = Conexa::Sale.list(
 )
 
 # Update sale
-Conexa::Sale.update(188510, quantity: 2, amount: 150.00)
+sale = Conexa::Sale.find(188510)
+sale.quantity = 2
+sale.amount = 150.00
+sale.save
 
 # Delete sale (only if not billed)
-Conexa::Sale.delete(188510)
+Conexa::Sale.destroy(188510)
 ```
 
 ### Recurring Sale
@@ -209,20 +214,20 @@ recurring = Conexa::RecurringSale.create(
 )
 
 # List recurring sales for a contract
-Conexa::RecurringSale.list(contract_id: 456)
+Conexa::RecurringSale.all(contract_id: 456)
 ```
 
 ### Charge
 
 ```ruby
 # Retrieve charge
-charge = Conexa::Charge.retrieve(789)
+charge = Conexa::Charge.find(789)
 charge.status     # => "paid"
 charge.amount     # => 299.90
 charge.due_date   # => "2024-02-10"
 
 # List charges
-charges = Conexa::Charge.list(
+charges = Conexa::Charge.all(
   customer_id: [127],
   status: 'pending',
   due_date_from: '2024-01-01',
@@ -240,10 +245,10 @@ Conexa::Charge.send_email(789)
 
 ```ruby
 # Retrieve bill
-bill = Conexa::Bill.retrieve(101)
+bill = Conexa::Bill.find(101)
 
 # List bills
-bills = Conexa::Bill.list(
+bills = Conexa::Bill.all(
   customer_id: [127],
   page: 1,
   size: 50
@@ -254,10 +259,10 @@ bills = Conexa::Bill.list(
 
 ```ruby
 # List plans
-plans = Conexa::Plan.list(company_id: [3])
+plans = Conexa::Plan.all(company_id: [3])
 
 # Retrieve plan
-plan = Conexa::Plan.retrieve(5)
+plan = Conexa::Plan.find(5)
 plan.name   # => "Plano Básico"
 plan.price  # => 99.90
 ```
@@ -266,10 +271,75 @@ plan.price  # => 99.90
 
 ```ruby
 # List products
-products = Conexa::Product.list(company_id: [3])
+products = Conexa::Product.all(company_id: [3], limit: 50)
 
 # Retrieve product
-product = Conexa::Product.retrieve(101)
+product = Conexa::Product.find(101)
+
+# Create product
+product = Conexa::Product.create(name: 'Novo Produto', company_id: 3)
+
+# Delete product
+Conexa::Product.destroy(101)
+```
+
+### Receiving Method
+
+```ruby
+methods = Conexa::ReceivingMethod.all(limit: 50)
+method = Conexa::ReceivingMethod.find(11)
+method.name  # => "Cartão de Crédito"
+```
+
+### Payment Method
+
+```ruby
+methods = Conexa::PaymentMethod.all(limit: 50)
+method = Conexa::PaymentMethod.find(2)
+```
+
+### Bill Category / Subcategory
+
+```ruby
+categories = Conexa::BillCategory.all(limit: 50)
+subcategories = Conexa::BillSubcategory.all(limit: 50)
+```
+
+### Cost Center
+
+```ruby
+centers = Conexa::CostCenter.all(limit: 50)
+center = Conexa::CostCenter.find(11)
+```
+
+### Account
+
+```ruby
+accounts = Conexa::Account.all(limit: 50)
+account = Conexa::Account.find(23)
+```
+
+### Service Category
+
+```ruby
+categories = Conexa::ServiceCategory.all(limit: 50)
+category = Conexa::ServiceCategory.find(1)
+```
+
+### Room Booking
+
+```ruby
+# List bookings
+bookings = Conexa::RoomBooking.all(limit: 20)
+
+# Create booking
+booking = Conexa::RoomBooking.create(room_id: 5, customer_id: 127)
+
+# Cancel booking
+Conexa::RoomBooking.cancel(143063)
+
+# Checkin
+Conexa::RoomBooking.checkin(room_id: 5, customer_id: 127)
 ```
 
 ### Credit Card
@@ -286,45 +356,137 @@ card = Conexa::CreditCard.create(
 )
 
 # List customer's cards
-cards = Conexa::CreditCard.list(customer_id: 127)
+cards = Conexa::CreditCard.all(customer_id: 127)
 
 # Delete card
-Conexa::CreditCard.delete(card_id)
+Conexa::CreditCard.destroy(card_id)
 ```
 
 ### Company (Unit)
 
 ```ruby
 # List companies/units
-companies = Conexa::Company.list
+companies = Conexa::Company.all
 
 # Retrieve company
-company = Conexa::Company.retrieve(3)
+company = Conexa::Company.find(3)
 company.name      # => "Matriz"
 company.document  # => "12.345.678/0001-90"
 ```
 
 ## Pagination
 
-All list endpoints return paginated results:
+### New Pagination (recommended) — `limit`/`offset`/`hasNext`
 
 ```ruby
-result = Conexa::Customer.list(page: 1, size: 20)
+result = Conexa::Customer.all(limit: 50)
+
+result.data                    # Array of customers
+result.pagination.limit        # => 50
+result.pagination.offset       # => 0
+result.has_next?               # => true/false
+
+# Iterate through all pages using next_page
+result = Conexa::Customer.all(limit: 50)
+loop do
+  result.data.each { |customer| process(customer) }
+  break unless result.has_next?
+  result = result.next_page
+end
+
+# Or manually with offset
+offset = 0
+loop do
+  result = Conexa::Customer.all(limit: 50, offset: offset)
+  result.data.each { |customer| process(customer) }
+  break unless result.has_next?
+  offset += 50
+end
+```
+
+### Legacy Pagination (deprecated — will be removed 2026-08-01)
 
-result.data                       # Array of customers
+```ruby
+# Still works but emits a deprecation warning
+result = Conexa::Customer.all(page: 1, size: 20)
 result.pagination.current_page    # => 1
 result.pagination.total_pages     # => 10
-result.pagination.total_items     # => 195
-result.pagination.item_per_page   # => 20
+```
+
+### Migration Guide: Legacy → New Pagination
 
-# Iterate through pages
+The legacy `page`/`size` pagination is deprecated and will be removed on **2026-08-01**. Follow these steps to migrate:
+
+#### 1. Replace `page`/`size` with `limit`/`offset`
+
+```ruby
+# BEFORE (legacy — deprecated)
+result = Conexa::Customer.all(page: 1, size: 50)
+result = Conexa::Customer.all(page: 2, size: 50)
+
+# AFTER (new)
+result = Conexa::Customer.all(limit: 50)               # offset defaults to 0
+result = Conexa::Customer.all(limit: 50, offset: 50)   # second page
+```
+
+**Conversion formula:** `offset = (page - 1) * size`
+
+#### 2. Update pagination metadata access
+
+```ruby
+# BEFORE (legacy)
+result.pagination  # => { "page" => 1, "size" => 50, "total" => 150 }
+total_pages = (result.pagination["total"].to_f / size).ceil
+
+# AFTER (new)
+result.pagination.limit      # => 50
+result.pagination.offset     # => 0
+result.pagination.has_next   # => true/false
+```
+
+#### 3. Update iteration loops
+
+```ruby
+# BEFORE (legacy)
+page = 1
 loop do
-  result.data.each { |customer| process(customer) }
-  break if result.pagination.current_page >= result.pagination.total_pages
-  result = Conexa::Customer.list(page: result.pagination.current_page + 1)
+  result = Conexa::Customer.all(page: page, size: 100)
+  break if result.empty?
+  result.data.each { |c| process(c) }
+  page += 1
+end
+
+# AFTER (new — using next_page)
+result = Conexa::Customer.all(limit: 100)
+loop do
+  result.data.each { |c| process(c) }
+  break unless result.has_next?
+  result = result.next_page
 end
 ```
 
+#### 4. Remove positional arguments
+
+```ruby
+# BEFORE (legacy positional args)
+Conexa::Customer.all(2, 50)           # page 2, size 50
+Conexa::Customer.find_by({}, 1, 20)   # page 1, size 20
+
+# AFTER (new keyword args)
+Conexa::Customer.all(limit: 50, offset: 50)
+Conexa::Customer.find_by(limit: 20)
+```
+
+#### Quick reference
+
+| Legacy | New |
+|---|---|
+| `page: 1, size: 50` | `limit: 50` (offset defaults to 0) |
+| `page: N, size: S` | `limit: S, offset: (N-1)*S` |
+| `pagination["total"]` | `pagination.has_next` |
+| `pagination["page"]` | `pagination.offset` |
+| Positional `(page, size)` | Keyword `limit:`, `offset:` |
+
 ## Error Handling
 
 ```ruby
@@ -332,35 +494,28 @@ begin
   customer = Conexa::Customer.create(name: '')
 rescue Conexa::ValidationError => e
   # Field validation errors (400)
-  e.errors.each do |error|
-    puts "#{error['field']}: #{error['messages'].join(', ')}"
-  end
-rescue Conexa::AuthenticationError => e
-  # Authentication required (401)
-  puts e.message
-rescue Conexa::AuthorizationError => e
-  # Not authorized (403)
   puts e.message
-rescue Conexa::NotFoundError => e
+rescue Conexa::NotFound => e
   # Resource not found (404)
   puts e.message
-rescue Conexa::UnprocessableError => e
-  # Business logic error (422)
-  e.errors.each do |error|
-    puts "#{error['code']}: #{error['message']}"
-  end
-rescue Conexa::RateLimitError => e
-  # Too many requests (429)
-  puts "Rate limit exceeded. Retry after #{e.retry_after} seconds"
-rescue Conexa::ApiError => e
-  # Generic API error
-  puts "Error #{e.status}: #{e.message}"
+rescue Conexa::ResponseError => e
+  # API response error (4xx/5xx)
+  puts e.message
+rescue Conexa::RequestError => e
+  # Request-level error (invalid params, etc.)
+  puts e.message
+rescue Conexa::ConnectionError => e
+  # Network/connection error
+  puts e.message
+rescue Conexa::ConexaError => e
+  # Generic Conexa error (catch-all)
+  puts e.message
 end
 ```
 
 ## Rate Limiting
 
-The Conexa API has a limit of **100 requests per minute**. Response headers include:
+The Conexa API has a limit of **100 requests per minute** (changing to **60 requests per minute** on 2026-04-27). Response headers include:
 
 - `X-Rate-Limit-Limit`: Maximum requests in 60s
 - `X-Rate-Limit-Remaining`: Remaining requests in 60s

data/README_pt-BR.md

@@ -73,25 +73,27 @@ Cada recurso segue um conjunto consistente de padrões de métodos:
 
 ### Paginação
 
-A API utiliza os parâmetros `page` e `size` para paginação com os seguintes valores padrão:
-
-- **page**: Número da página atual (padrão: `1`)
-- **size**: Quantidade de itens por página (padrão: `100`)
+A gem utiliza por padrão `limit: 100, offset: 0` (nova paginação). O modelo legado `page`/`size` ainda funciona mas emite um aviso de depreciação.
 
 #### Chamando com Paginação
 
 ```ruby
-# Paginação padrão (página 1, 100 itens)
+# Paginação padrão (limit: 100, offset: 0)
 Conexa::Customer.all
 
-# Argumentos posicionais (página, tamanho)
-Conexa::Customer.all(2, 50)  # página 2, 50 itens por página
+# Com limite customizado
+Conexa::Customer.all(limit: 50)
 
-# Parâmetros nomeados
-Conexa::Customer.all(page: 3, size: 25)
+# Com offset
+Conexa::Customer.all(limit: 50, offset: 100)
 
-# Usando o alias `where`
-Conexa::Customer.where(page: 2, size: 10)
+# Iteração automática com next_page
+resultado = Conexa::Customer.all(limit: 50)
+loop do
+  resultado.data.each { |cliente| processa(cliente) }
+  break unless resultado.has_next?
+  resultado = resultado.next_page
+end
 ```
 
 ### Objeto Result
@@ -281,7 +283,7 @@ paginacao = pagina1.pagination
 # paginacao contém total de registros, total de páginas, etc.
 ```
 
-#### Iterando Por Todas as Páginas
+#### Iterando Por Todas as Páginas (legado — depreciado)
 
 ```ruby
 pagina = 1
@@ -301,6 +303,108 @@ loop do
 end
 ```
 
+### Nova Paginação (recomendada) — `limit`/`offset`/`hasNext`
+
+```ruby
+resultado = Conexa::Customer.all(limit: 50)
+
+resultado.data                    # Array de clientes
+resultado.pagination.limit        # => 50
+resultado.pagination.offset       # => 0
+resultado.has_next?               # => true/false
+
+# Iterar por todas as páginas usando next_page
+resultado = Conexa::Customer.all(limit: 50)
+loop do
+  resultado.data.each { |cliente| processa(cliente) }
+  break unless resultado.has_next?
+  resultado = resultado.next_page
+end
+
+# Ou manualmente com offset
+offset = 0
+loop do
+  resultado = Conexa::Customer.all(limit: 50, offset: offset)
+  resultado.data.each { |cliente| processa(cliente) }
+  break unless resultado.has_next?
+  offset += 50
+end
+```
+
+### Guia de Migração: Paginação Legada → Nova
+
+A paginação legada `page`/`size` está depreciada e será removida em **01/08/2026**. Siga estes passos para migrar:
+
+#### 1. Substitua `page`/`size` por `limit`/`offset`
+
+```ruby
+# ANTES (legado — depreciado)
+resultado = Conexa::Customer.all(page: 1, size: 50)
+resultado = Conexa::Customer.all(page: 2, size: 50)
+
+# DEPOIS (novo)
+resultado = Conexa::Customer.all(limit: 50)               # offset padrão 0
+resultado = Conexa::Customer.all(limit: 50, offset: 50)   # segunda página
+```
+
+**Fórmula de conversão:** `offset = (page - 1) * size`
+
+#### 2. Atualize o acesso aos metadados de paginação
+
+```ruby
+# ANTES (legado)
+resultado.pagination  # => { "page" => 1, "size" => 50, "total" => 150 }
+total_paginas = (resultado.pagination["total"].to_f / tamanho).ceil
+
+# DEPOIS (novo)
+resultado.pagination.limit      # => 50
+resultado.pagination.offset     # => 0
+resultado.pagination.has_next   # => true/false
+```
+
+#### 3. Atualize os loops de iteração
+
+```ruby
+# ANTES (legado)
+pagina = 1
+loop do
+  resultado = Conexa::Customer.all(page: pagina, size: 100)
+  break if resultado.empty?
+  resultado.data.each { |c| processa(c) }
+  pagina += 1
+end
+
+# DEPOIS (novo — usando next_page)
+resultado = Conexa::Customer.all(limit: 100)
+loop do
+  resultado.data.each { |c| processa(c) }
+  break unless resultado.has_next?
+  resultado = resultado.next_page
+end
+```
+
+#### 4. Remova argumentos posicionais
+
+```ruby
+# ANTES (argumentos posicionais legados)
+Conexa::Customer.all(2, 50)           # página 2, tamanho 50
+Conexa::Customer.find_by({}, 1, 20)   # página 1, tamanho 20
+
+# DEPOIS (argumentos nomeados)
+Conexa::Customer.all(limit: 50, offset: 50)
+Conexa::Customer.find_by(limit: 20)
+```
+
+#### Referência rápida
+
+| Legado | Novo |
+|---|---|
+| `page: 1, size: 50` | `limit: 50` (offset padrão 0) |
+| `page: N, size: S` | `limit: S, offset: (N-1)*S` |
+| `pagination["total"]` | `pagination.has_next` |
+| `pagination["page"]` | `pagination.offset` |
+| Posicional `(page, size)` | Nomeado `limit:`, `offset:` |
+
 ### Exemplos
 
 #### Clientes (Customers)